cli turned out to be stupidly cool

Author: riofriz

package.json

@@ -1,6 +1,6 @@
 {
   "name": "degoog-cli",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "CLI toolset for degoog",
   "type": "module",
   "scripts": {

src/commands/create.ts

@@ -1,4 +1,5 @@
 import * as p from "@clack/prompts";
+import { join } from "node:path";
 import { ExtType, type GeneratorCtx } from "../types/index.ts";
 import { promptExtType } from "../prompts/ext-type.ts";
 import { generateEngine } from "../generators/engine.ts";
@@ -13,6 +14,13 @@ import { generatePluginMid } from "../generators/plugin-mid.ts";
 import { generatePluginRoute } from "../generators/plugin-route.ts";
 import { loadConfig } from "../config/store.ts";
 import { argv } from "../utils/argv.ts";
+import {
+  extTypeToCategory,
+  findStoreRoot,
+  registerExtensionInStore,
+  scaffoldStore,
+} from "../utils/store.ts";
+import { t } from "../utils/theme.ts";
 
 const SLUG_RE = /^[a-z][a-z0-9-]*$/;
 
@@ -31,6 +39,43 @@ const GENERATORS: Record<ExtType, (ctx: GeneratorCtx) => Promise<string>> = {
   [ExtType.PluginRoutes]: generatePluginRoute,
 };
 
+const resolveOutDir = async (
+  extType: ExtType,
+  config: Awaited<ReturnType<typeof loadConfig>>,
+): Promise<string | null> => {
+  if (argv.out) return argv.out;
+
+  const category = extTypeToCategory(extType);
+  let store = await findStoreRoot(process.cwd());
+
+  if (store) {
+    p.log.info(t.muted(`store detected — creating in ${category}/`));
+    return join(store.dir, category);
+  }
+
+  const setup = await p.confirm({
+    message: "No store detected. Set up a store in the current directory?",
+    initialValue: true,
+  });
+  if (p.isCancel(setup)) return null;
+
+  if (setup) {
+    await scaffoldStore(process.cwd(), config);
+    store = await findStoreRoot(process.cwd());
+    if (store) {
+      p.log.info(t.muted(`store created — creating in ${category}/`));
+      return join(store.dir, category);
+    }
+  }
+
+  const input = await p.text({
+    message: "Output directory",
+    placeholder: ".",
+  });
+  if (p.isCancel(input)) return null;
+  return input || ".";
+};
+
 export const createCmd = async () => {
   let name: string
 
@@ -60,23 +105,18 @@ export const createCmd = async () => {
     extType = picked
   }
 
-  let outDir: string
-
-  if (argv.out) {
-    outDir = argv.out
-  } else {
-    const input = await p.text({
-      message: "Output directory",
-      initialValue: ".",
-    })
-    if (p.isCancel(input)) return
-    outDir = input || "."
-  }
-
   const config = await loadConfig()
+  const outDir = await resolveOutDir(extType, config)
+  if (!outDir) return
+
   const ctx: GeneratorCtx = { name, outDir, config }
 
-  await GENERATORS[extType](ctx)
+  const createdPath = await GENERATORS[extType](ctx)
+
+  const store = await findStoreRoot(createdPath)
+  if (store) {
+    await registerExtensionInStore(store.dir, name, extType)
+  }
 
   p.note(
     `That's it, you now have a sexy template for your extension. Have fun making it your own!`,

src/commands/doctor/checks.ts

@@ -1,6 +1,7 @@
 import { readFile, writeFile, readdir } from "node:fs/promises"
 import { join, basename } from "node:path"
 import { exists } from "./detect.ts"
+import { findStoreRoot } from "../../utils/store.ts"
 import type { CheckResult, ExtensionKind, RunSummary } from "./types.ts"
 
 const readJson = async <T>(path: string): Promise<T | null> => {
@@ -279,9 +280,12 @@ export const runChecks = async (
     if (themeRes.failed) failed = true
   }
 
-  const authorRes = await checkAuthorJson(dir, doFix)
-  results.push(authorRes.result)
-  if (authorRes.failed) failed = true
+  const inStore = await findStoreRoot(dir)
+  if (!inStore) {
+    const authorRes = await checkAuthorJson(dir, doFix)
+    results.push(authorRes.result)
+    if (authorRes.failed) failed = true
+  }
 
   if (kind === "plugin") {
     const routeChecks = await checkRouteConventions(dir, doFix)

src/commands/doctor/detect.ts

@@ -1,16 +1,9 @@
-import { access, readFile } from "node:fs/promises"
 import { join, basename, dirname } from "node:path"
-import type { ExtensionKind, StoreManifest, Target } from "./types.ts"
-import { EXTENSION_CATEGORIES } from "./types.ts"
+import { exists } from "../../utils/files.ts"
+import { readStoreManifest } from "../../utils/store.ts"
+import type { ExtensionKind, Target } from "./types.ts"
 
-export const exists = async (path: string): Promise<boolean> => {
-  try {
-    await access(path)
-    return true
-  } catch {
-    return false
-  }
-}
+export { exists }
 
 const KIND_FROM_FOLDER: Record<string, ExtensionKind> = {
   themes: "theme",
@@ -37,25 +30,10 @@ export const detectExtKind = async (dir: string): Promise<ExtensionKind> => {
   return detectKindFromParent(dir)
 }
 
-const readStoreManifest = async (
-  dir: string,
-): Promise<{ path: string; manifest: StoreManifest } | null> => {
-  const path = join(dir, "package.json")
-  if (!(await exists(path))) return null
-  try {
-    const manifest = JSON.parse(await readFile(path, "utf-8")) as StoreManifest
-    const hasAny = EXTENSION_CATEGORIES.some((c) => Array.isArray(manifest[c]))
-    if (!hasAny) return null
-    return { path, manifest }
-  } catch {
-    return null
-  }
-}
-
 export const detectTarget = async (dir: string): Promise<Target | null> => {
   const store = await readStoreManifest(dir)
   if (store) {
-    return { kind: "store", dir, manifestPath: store.path, manifest: store.manifest }
+    return { kind: "store", dir, manifestPath: store.manifestPath, manifest: store.manifest }
   }
   if (await isExtensionDir(dir)) {
     const extKind = await detectExtKind(dir)

src/commands/search.ts

@@ -16,6 +16,14 @@ type SearchResp = {
   relatedSearches: string[];
 };
 
+const PAGE_SIZE = 10;
+
+const parseSearchQuery = (): string | undefined => {
+  const argStart = process.argv[2] === "search" ? 3 : 2;
+  const args = process.argv.slice(argStart).filter((a) => !a.startsWith("-"));
+  return args.length ? args.join(" ") : undefined;
+};
+
 const openUrl = (url: string) => {
   const cmd = process.platform === "darwin" ? "open" : "xdg-open";
   try {
@@ -46,19 +54,28 @@ const wrap = (text: string, width: number): string[] => {
 const truncate = (s: string, max: number) =>
   s.length > max ? s.slice(0, max - 1) + "…" : s;
 
-const renderResults = (data: SearchResp) => {
+const totalPages = (count: number) => Math.max(1, Math.ceil(count / PAGE_SIZE));
+
+const renderResults = (
+  data: SearchResp,
+  page: number,
+  showRelated: boolean,
+) => {
   const cols = process.stdout.columns ?? 100;
   const maxWidth = Math.min(cols - 8, 90);
   const pad = "      ";
+  const pages = totalPages(data.results.length);
+  const start = (page - 1) * PAGE_SIZE;
+  const pageResults = data.results.slice(start, start + PAGE_SIZE);
 
   console.log();
   console.log(
-    `  ${t.muted(`${data.results.length} results · ${data.totalTime}ms`)}`,
+    `  ${t.muted(`page ${page}/${pages} · ${data.results.length} results · ${data.totalTime}ms`)}`,
   );
   console.log();
 
-  data.results.forEach((r, i) => {
-    const num = t.dim(`  ${String(i + 1).padStart(2)}  `);
+  pageResults.forEach((r, i) => {
+    const num = t.dim(`  ${String(start + i + 1).padStart(2)}  `);
     console.log(`${num}${t.bold(t.brand(truncate(r.title, maxWidth)))}`);
     console.log(`${pad}${t.success(truncate(r.url, maxWidth))}`);
 
@@ -74,7 +91,7 @@ const renderResults = (data: SearchResp) => {
     console.log();
   });
 
-  if (data.relatedSearches?.length) {
+  if (showRelated && data.relatedSearches?.length) {
     const related = data.relatedSearches
       .slice(0, 5)
       .map((s) => t.primary(s))
@@ -105,49 +122,58 @@ const doSearch = async (
   return result.data;
 };
 
-export const searchCmd = async () => {
-  const config = await loadConfig();
+const promptQuery = async (): Promise<string | null> => {
+  const query = await p.text({
+    message: t.brand("search"),
+    placeholder: "what are you looking for?",
+  });
+  if (p.isCancel(query) || !query) return null;
+  return query;
+};
 
-  if (!config.instanceUrl) {
-    p.log.warn(t.warning("no instance configured - run Login / Setup first"));
-    return;
-  }
+const browseResults = async (data: SearchResp): Promise<"again" | "back"> => {
+  let page = 1;
+  const pages = totalPages(data.results.length);
 
   while (true) {
-    const query = await p.text({
-      message: t.brand("search"),
-      placeholder: "what are you looking for?",
-    });
-    if (p.isCancel(query) || !query) return;
-
-    const data = await doSearch(query, config);
-    if (!data) return;
-
-    if (!data.results.length) {
-      p.log.warn(t.muted("no results found"));
-      continue;
-    }
-
-    renderResults(data);
-
-    const openOpts = data.results.slice(0, 5).map((r, i) => ({
-      value: `open:${i}`,
-      label: t.text(`open #${i + 1}`),
-      hint: truncate(r.title, 50),
-    }));
+    renderResults(data, page, page === 1);
+
+    const openOpts = data.results
+      .slice((page - 1) * PAGE_SIZE, page * PAGE_SIZE)
+      .map((r, i) => ({
+        value: `open:${(page - 1) * PAGE_SIZE + i}`,
+        label: t.text(truncate(r.title, 60)),
+      }));
+
+    const navOpts = [
+      ...(page > 1
+        ? [{ value: "prev", label: t.muted("previous page") }]
+        : []),
+      ...(page < pages
+        ? [{ value: "next", label: t.muted("next page") }]
+        : []),
+    ];
 
     const action = await p.select({
       message: t.muted("open a result, search again, or go back"),
       options: [
         ...openOpts,
+        ...navOpts,
         { value: "again", label: t.muted("search again") },
         { value: "back", label: t.muted("back to menu") },
       ],
     });
 
-    if (p.isCancel(action) || action === "back") return;
-
-    if (action === "again") continue;
+    if (p.isCancel(action) || action === "back") return "back";
+    if (action === "again") return "again";
+    if (action === "next") {
+      page = Math.min(page + 1, pages);
+      continue;
+    }
+    if (action === "prev") {
+      page = Math.max(page - 1, 1);
+      continue;
+    }
 
     if (typeof action === "string" && action.startsWith("open:")) {
       const idx = parseInt(action.slice(5), 10);
@@ -156,3 +182,32 @@ export const searchCmd = async () => {
     }
   }
 };
+
+export const searchCmd = async () => {
+  const config = await loadConfig();
+
+  if (!config.instanceUrl) {
+    p.log.warn(t.warning("no instance configured - run Login / Setup first"));
+    return;
+  }
+
+  let pendingQuery = parseSearchQuery();
+
+  while (true) {
+    const query = pendingQuery ?? (await promptQuery());
+    pendingQuery = undefined;
+
+    if (!query) return;
+
+    const data = await doSearch(query, config);
+    if (!data) return;
+
+    if (!data.results.length) {
+      p.log.warn(t.muted("no results found"));
+      continue;
+    }
+
+    const action = await browseResults(data);
+    if (action === "back") return;
+  }
+};

src/utils/files.ts

@@ -1,4 +1,4 @@
-import { mkdir, writeFile } from "node:fs/promises"
+import { mkdir, writeFile, access } from "node:fs/promises"
 import { join, resolve, dirname } from "node:path"
 import { logger } from "./logger.ts"
 import type { Config } from "../types/index.ts"
@@ -8,6 +8,15 @@ export const mkdirp = async (dir: string) => {
   await mkdir(dir, { recursive: true })
 }
 
+export const exists = async (path: string): Promise<boolean> => {
+  try {
+    await access(path)
+    return true
+  } catch {
+    return false
+  }
+}
+
 export const writeOut = async (filePath: string, content: string | HTMLBundle) => {
   // @ts-expect-error - Bun supports writing HTMLBundles
   await writeFile(filePath, content, "utf8")