bet-cli 0.2.0 → 0.3.0

package/src/commands/update.ts

@@ -3,7 +3,12 @@ import readline from "node:readline";
 import { Command } from "commander";
 import { readConfig, resolveRoots, writeConfig } from "../lib/config.js";
 import { normalizeAbsolute } from "../utils/paths.js";
-import { installUpdateCron, uninstallUpdateCron, parseCronSchedule, formatScheduleLabel } from "../lib/cron.js";
+import {
+  installUpdateCron,
+  uninstallUpdateCron,
+  parseCronSchedule,
+  formatScheduleLabel,
+} from "../lib/cron.js";
 import { scanRoots } from "../lib/scan.js";
 import { computeMetadata } from "../lib/metadata.js";
 import { getEffectiveIgnores, isPathIgnored } from "../lib/ignore.js";
@@ -30,16 +35,16 @@ export function willOverrideRoots(
   providedRootConfigs: RootConfig[] | undefined,
   configRoots: RootConfig[],
 ): boolean {
-  return !!(
-    providedRootConfigs !== undefined &&
-    configRoots.length > 0
-  );
+  return !!(providedRootConfigs !== undefined && configRoots.length > 0);
 }
 
 const DEFAULT_SLUG_PARENT_FOLDERS = ["src", "app"];
 
 export { DEFAULT_SLUG_PARENT_FOLDERS };
-export function projectSlug(pathName: string, slugParentFolders: string[]): string {
+export function projectSlug(
+  pathName: string,
+  slugParentFolders: string[],
+): string {
   const folderName = path.basename(pathName);
   if (slugParentFolders.includes(folderName)) {
     return path.basename(path.dirname(pathName));
@@ -47,8 +52,14 @@ export function projectSlug(pathName: string, slugParentFolders: string[]): stri
   return folderName;
 }
 
-async function promptYesNo(question: string, defaultNo = true): Promise<boolean> {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+async function promptYesNo(
+  question: string,
+  defaultNo = true,
+): Promise<boolean> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stderr,
+  });
   return new Promise((resolve) => {
     const defaultHint = defaultNo ? "y/N" : "Y/n";
     rl.question(question + " [" + defaultHint + "] ", (answer) => {
@@ -69,166 +80,209 @@ export function registerUpdate(program: Command): void {
     .description("Scan roots and update the project index")
     .option("--roots <paths>", "Comma-separated list of roots to scan")
     .option("--force", "Allow overriding configured roots when not in TTY")
-    .option("--cron [frequency]", "Run update on a schedule: Nm/Nh/Nd e.g. 5m, 1h, 2d (default 1h), or 0/false to disable")
-    .action(async (options: { roots?: string; force?: boolean; cron?: boolean | string }) => {
-      try {
-      const config = await readConfig();
-      const providedPaths = parseRoots(options.roots);
-      const providedRootConfigs = providedPaths
-        ? pathsToRootConfigs(providedPaths)
-        : undefined;
-      const configRoots = config.roots.length > 0 ? config.roots : undefined;
-      const rootsToUse = providedRootConfigs ?? configRoots;
-
-      if (!rootsToUse || rootsToUse.length === 0) {
-        log.error("update failed: no roots specified");
-        process.stderr.write(
-          "Error: No roots specified. Please provide roots using --roots option.\n" +
-            "Example: bet update --roots /path/to/your/code\n",
-        );
-        process.exitCode = 1;
-        return;
-      }
+    .option(
+      "--cron [frequency]",
+      "Run update on a schedule: Nm/Nh/Nd e.g. 5m, 1h, 2d (default 1h), or 0/false to disable",
+    )
+    .action(
+      async (options: {
+        roots?: string;
+        force?: boolean;
+        cron?: boolean | string;
+      }) => {
+        try {
+          const config = await readConfig();
+          const providedPaths = parseRoots(options.roots);
+          const providedRootConfigs = providedPaths
+            ? pathsToRootConfigs(providedPaths)
+            : undefined;
+          const configRoots =
+            config.roots.length > 0 ? config.roots : undefined;
+          const rootsToUse = providedRootConfigs ?? configRoots;
 
-      const willOverride = willOverrideRoots(providedRootConfigs, config.roots);
-
-      if (willOverride) {
-        log.warn("--roots overrides configured roots", "configured:", configRoots!.map((r) => r.path).join(", "), "provided:", providedRootConfigs!.map((r) => r.path).join(", "));
-        process.stderr.write(
-          "Warning: --roots will override your configured roots.\n" +
-            "  Configured: " +
-            configRoots!.map((r) => r.path).join(", ") +
-            "\n  Provided:   " +
-            providedRootConfigs!.map((r) => r.path).join(", ") +
-            "\n",
-        );
-        if (!process.stdin.isTTY) {
-          if (!options.force) {
-            log.error("update failed: refusing to override roots without confirmation (use --force when not in TTY)");
+          if (!rootsToUse || rootsToUse.length === 0) {
+            log.error("update failed: no roots specified");
             process.stderr.write(
-              "Error: Refusing to override without confirmation. Run interactively or use --force.\n",
+              "Error: No roots specified. Please provide roots using --roots option.\n" +
+                "Example: bet update --roots /path/to/your/code\n",
             );
             process.exitCode = 1;
             return;
           }
-        } else {
-          const confirmed = await promptYesNo("Continue?", true);
-          if (!confirmed) {
-            log.info("update aborted by user");
-            process.stderr.write("Aborted.\n");
-            return;
+
+          const willOverride = willOverrideRoots(
+            providedRootConfigs,
+            config.roots,
+          );
+
+          if (willOverride) {
+            log.warn(
+              "--roots overrides configured roots",
+              "configured:",
+              configRoots!.map((r) => r.path).join(", "),
+              "provided:",
+              providedRootConfigs!.map((r) => r.path).join(", "),
+            );
+            process.stderr.write(
+              "Warning: --roots will override your configured roots.\n" +
+                "  Configured: " +
+                configRoots!.map((r) => r.path).join(", ") +
+                "\n  Provided:   " +
+                providedRootConfigs!.map((r) => r.path).join(", ") +
+                "\n",
+            );
+            if (!process.stdin.isTTY) {
+              if (!options.force) {
+                log.error(
+                  "update failed: refusing to override roots without confirmation (use --force when not in TTY)",
+                );
+                process.stderr.write(
+                  "Error: Refusing to override without confirmation. Run interactively or use --force.\n",
+                );
+                process.exitCode = 1;
+                return;
+              }
+            } else {
+              const confirmed = await promptYesNo("Continue?", true);
+              if (!confirmed) {
+                log.info("update aborted by user");
+                process.stderr.write("Aborted.\n");
+                return;
+              }
+            }
           }
-        }
-      }
 
-      const rootsResolved = resolveRoots(rootsToUse);
-      const rootPaths = rootsResolved.map((r) => r.path);
-      log.info("update started", "roots=" + rootPaths.join(", "));
-      log.debug("scanning roots", rootPaths.length, "root(s)");
-      const ignores = getEffectiveIgnores(config);
-      const candidates = await scanRoots(rootPaths, ignores);
-      const ignoredPaths = config.ignoredPaths ?? [];
-      const filteredCandidates = candidates.filter(
-        (c) => !isPathIgnored(c.path, ignoredPaths),
-      );
-      log.debug("found", filteredCandidates.length, "candidate(s) after ignoring paths");
-      const projects: Record<string, Project> = {};
-
-      for (const candidate of filteredCandidates) {
-        const hasGit = await isInsideGitRepo(candidate.path);
-        const auto = await computeMetadata(candidate.path, hasGit, ignores);
-        const slug = projectSlug(candidate.path, config.slugParentFolders ?? DEFAULT_SLUG_PARENT_FOLDERS);
-        const existing = config.projects[candidate.path];
-        const rootConfig = rootsResolved.find((r) => r.path === candidate.root);
-        const rootName = rootConfig?.name ?? path.basename(candidate.root);
-
-        const project: Project = {
-          id: candidate.path,
-          slug,
-          name: slug,
-          path: candidate.path,
-          root: candidate.root,
-          rootName,
-          hasGit,
-          hasReadme: candidate.hasReadme,
-          auto,
-          user: existing?.user,
-        };
-
-        projects[candidate.path] = project;
-      }
+          const rootsResolved = resolveRoots(rootsToUse);
+          const rootPaths = rootsResolved.map((r) => r.path);
+          log.info("update started", "roots=" + rootPaths.join(", "));
+          log.debug("scanning roots", rootPaths.length, "root(s)");
+          const ignores = getEffectiveIgnores(config);
+          const candidates = await scanRoots(rootPaths, ignores);
+          const ignoredPaths = config.ignoredPaths ?? [];
+          const filteredCandidates = candidates.filter(
+            (c) => !isPathIgnored(c.path, ignoredPaths),
+          );
+          log.debug(
+            "found",
+            filteredCandidates.length,
+            "candidate(s) after ignoring paths",
+          );
+          const projects: Record<string, Project> = {};
+
+          for (const candidate of filteredCandidates) {
+            const hasGit = await isInsideGitRepo(candidate.path);
+            const auto = await computeMetadata(candidate.path, hasGit, ignores);
+            const slug = projectSlug(
+              candidate.path,
+              config.slugParentFolders ?? DEFAULT_SLUG_PARENT_FOLDERS,
+            );
+            const existing = config.projects[candidate.path];
+            const rootConfig = rootsResolved.find(
+              (r) => r.path === candidate.root,
+            );
+            const rootName = rootConfig?.name ?? path.basename(candidate.root);
+
+            const project: Project = {
+              id: candidate.path,
+              slug,
+              name: slug,
+              path: candidate.path,
+              root: candidate.root,
+              rootName,
+              hasGit,
+              hasReadme: candidate.hasReadme,
+              auto,
+              user: existing?.user,
+            };
+
+            projects[candidate.path] = project;
+          }
+
+          const nextConfig: Config = {
+            version: config.version ?? 1,
+            roots: rootsResolved,
+            projects,
+            updatedAt: new Date().toISOString(),
+            ...(config.ignores !== undefined && { ignores: config.ignores }),
+            ...(config.ignoredPaths !== undefined && {
+              ignoredPaths: config.ignoredPaths,
+            }),
+            ...(config.slugParentFolders !== undefined && {
+              slugParentFolders: config.slugParentFolders,
+            }),
+          };
+
+          await writeConfig(nextConfig);
+
+          const projectCount = Object.keys(projects).length;
+          const rootCount = rootsResolved.length;
+          log.info(
+            "update completed",
+            "projects=" + projectCount,
+            "roots=" + rootCount,
+          );
 
-      const nextConfig: Config = {
-        version: config.version ?? 1,
-        roots: rootsResolved,
-        projects,
-        updatedAt: new Date().toISOString(),
-        ...(config.ignores !== undefined && { ignores: config.ignores }),
-        ...(config.ignoredPaths !== undefined && { ignoredPaths: config.ignoredPaths }),
-        ...(config.slugParentFolders !== undefined && { slugParentFolders: config.slugParentFolders }),
-      };
-
-      await writeConfig(nextConfig);
-
-      const projectCount = Object.keys(projects).length;
-      const rootCount = rootsResolved.length;
-      log.info("update completed", "projects=" + projectCount, "roots=" + rootCount);
-
-      process.stdout.write(
-        "Indexed " +
-          projectCount +
-          " projects from " +
-          rootCount +
-          " root(s).\n",
-      );
-
-      if (options.cron !== undefined && options.cron !== false) {
-        const entryScriptPath = path.isAbsolute(process.argv[1] ?? "")
-          ? process.argv[1]
-          : path.resolve(process.cwd(), process.argv[1] ?? "dist/index.js");
-        const cronOpt = options.cron;
-        if (cronOpt === true) {
-          const { wrapperPath, logPath } = await installUpdateCron({
-            nodePath: process.execPath,
-            entryScriptPath,
-            schedule: "1h",
-          });
-          process.stdout.write("Installed cron for bet update (every hour).\n");
           process.stdout.write(
-            `  Wrapper script: ${wrapperPath}\n  Log file: ${logPath}\n  To view or edit crontab: crontab -l  /  crontab -e\n`,
+            "Indexed " +
+              projectCount +
+              " projects from " +
+              rootCount +
+              " root(s).\n",
           );
-        } else if (typeof cronOpt === "string") {
-          const normalized = cronOpt.trim().toLowerCase();
-          if (normalized === "0" || normalized === "false") {
-            await uninstallUpdateCron();
-            process.stdout.write("Removed cron for bet update.\n");
-          } else {
-            try {
-              const parsed = parseCronSchedule(cronOpt);
+
+          if (options.cron !== undefined && options.cron !== false) {
+            const entryScriptPath = path.isAbsolute(process.argv[1] ?? "")
+              ? process.argv[1]
+              : path.resolve(process.cwd(), process.argv[1] ?? "dist/index.js");
+            const cronOpt = options.cron;
+            if (cronOpt === true) {
               const { wrapperPath, logPath } = await installUpdateCron({
                 nodePath: process.execPath,
                 entryScriptPath,
-                schedule: cronOpt,
+                schedule: "1h",
               });
-              const label = formatScheduleLabel(parsed);
-              process.stdout.write(`Installed cron for bet update (${label}).\n`);
+              process.stdout.write(
+                "Installed cron for bet update (every hour).\n",
+              );
               process.stdout.write(
                 `  Wrapper script: ${wrapperPath}\n  Log file: ${logPath}\n  To view or edit crontab: crontab -l  /  crontab -e\n`,
               );
-            } catch (err) {
-              const message = err instanceof Error ? err.message : String(err);
-              log.error(err instanceof Error ? err : new Error(message));
-              process.stderr.write(`Error: ${message}\n`);
-              process.exitCode = 1;
+            } else if (typeof cronOpt === "string") {
+              const normalized = cronOpt.trim().toLowerCase();
+              if (normalized === "0" || normalized === "false") {
+                await uninstallUpdateCron();
+                process.stdout.write("Removed cron for bet update.\n");
+              } else {
+                try {
+                  const parsed = parseCronSchedule(cronOpt);
+                  const { wrapperPath, logPath } = await installUpdateCron({
+                    nodePath: process.execPath,
+                    entryScriptPath,
+                    schedule: cronOpt,
+                  });
+                  const label = formatScheduleLabel(parsed);
+                  process.stdout.write(
+                    `Installed cron for bet update (${label}).\n`,
+                  );
+                  process.stdout.write(
+                    `  Wrapper script: ${wrapperPath}\n  Log file: ${logPath}\n  To view or edit crontab: crontab -l  /  crontab -e\n`,
+                  );
+                } catch (err) {
+                  const message =
+                    err instanceof Error ? err.message : String(err);
+                  log.error(err instanceof Error ? err : new Error(message));
+                  process.stderr.write(`Error: ${message}\n`);
+                  process.exitCode = 1;
+                }
+              }
             }
           }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          log.error(err instanceof Error ? err : new Error(message));
+          process.stderr.write(`Error: ${message}\n`);
+          process.exitCode = 1;
         }
-      }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        log.error(err instanceof Error ? err : new Error(message));
-        process.stderr.write(`Error: ${message}\n`);
-        process.exitCode = 1;
-      }
-    });
+      },
+    );
 }

package/src/lib/config.ts

@@ -68,11 +68,25 @@ function normalizeIgnoredPaths(parsed: unknown): string[] | undefined {
   return list.length === 0 ? undefined : list;
 }
 
+function normalizeEditor(parsed: unknown): string | undefined {
+  if (typeof parsed !== "string") return undefined;
+  const trimmed = parsed.trim();
+  return trimmed.length === 0 ? undefined : trimmed;
+}
+
 async function readAppConfig(): Promise<AppConfig> {
   try {
     const raw = await fs.readFile(CONFIG_PATH, "utf8");
-    const parsed = JSON.parse(raw) as { version?: number; roots?: unknown; ignores?: unknown; ignoredPaths?: unknown; slugParentFolders?: unknown };
+    const parsed = JSON.parse(raw) as {
+      version?: number;
+      roots?: unknown;
+      editor?: unknown;
+      ignores?: unknown;
+      ignoredPaths?: unknown;
+      slugParentFolders?: unknown;
+    };
     const roots = normalizeRoots(parsed.roots ?? []);
+    const editor = normalizeEditor(parsed.editor);
     const ignores = normalizeIgnores(parsed.ignores);
     const ignoredPaths = normalizeIgnoredPaths(parsed.ignoredPaths);
     const slugParentFolders = normalizeSlugParentFolders(parsed.slugParentFolders);
@@ -80,6 +94,7 @@ async function readAppConfig(): Promise<AppConfig> {
       ...DEFAULT_APP_CONFIG,
       version: parsed.version ?? 1,
       roots,
+      ...(editor !== undefined && { editor }),
       ...(ignores !== undefined && { ignores }),
       ...(ignoredPaths !== undefined && { ignoredPaths }),
       ...(slugParentFolders !== undefined && { slugParentFolders }),
@@ -146,6 +161,7 @@ export async function writeConfig(config: Config): Promise<void> {
   const appConfig: AppConfig = {
     version: config.version,
     roots: config.roots,
+    ...(config.editor !== undefined && { editor: config.editor }),
     ...(config.ignores !== undefined && { ignores: config.ignores }),
     ...(config.ignoredPaths !== undefined && { ignoredPaths: config.ignoredPaths }),
     ...(config.slugParentFolders !== undefined && { slugParentFolders: config.slugParentFolders }),

package/src/lib/editor.ts

@@ -0,0 +1,131 @@
+import { spawn } from "node:child_process";
+
+export type LaunchCommand = {
+  command: string;
+  args: string[];
+};
+
+function tokenizeCommand(input: string): string[] {
+  const tokens: string[] = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  let escaped = false;
+
+  for (const char of input) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+
+    if (char === "'" && !inDouble) {
+      inSingle = !inSingle;
+      continue;
+    }
+
+    if (char === '"' && !inSingle) {
+      inDouble = !inDouble;
+      continue;
+    }
+
+    if (!inSingle && !inDouble && /\s/.test(char)) {
+      if (current.length > 0) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+
+    current += char;
+  }
+
+  if (escaped || inSingle || inDouble) {
+    throw new Error("Invalid editor command in config.");
+  }
+
+  if (current.length > 0) {
+    tokens.push(current);
+  }
+
+  return tokens;
+}
+
+export function parseEditorCommand(editor: string): LaunchCommand {
+  const trimmed = editor.trim();
+  if (!trimmed) {
+    throw new Error("Config editor must not be empty.");
+  }
+
+  const tokens = tokenizeCommand(trimmed);
+  if (tokens.length === 0) {
+    throw new Error("Config editor must not be empty.");
+  }
+
+  const [command, ...args] = tokens;
+  return { command, args };
+}
+
+export function getSystemOpenCommand(
+  targetPath: string,
+  platform: NodeJS.Platform = process.platform,
+): LaunchCommand {
+  if (platform === "darwin") {
+    return { command: "open", args: [targetPath] };
+  }
+
+  if (platform === "win32") {
+    return { command: "cmd", args: ["/c", "start", "", targetPath] };
+  }
+
+  return { command: "xdg-open", args: [targetPath] };
+}
+
+function getEnvEditor(env: NodeJS.ProcessEnv): string | undefined {
+  const visual = env.VISUAL?.trim();
+  if (visual) return visual;
+
+  const editor = env.EDITOR?.trim();
+  if (editor) return editor;
+
+  return undefined;
+}
+
+function spawnDetached(command: string, args: string[]): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      detached: true,
+      stdio: "ignore",
+    });
+
+    child.once("error", (error) => {
+      reject(error);
+    });
+
+    child.once("spawn", () => {
+      child.unref();
+      resolve();
+    });
+  });
+}
+
+export async function openProjectInEditor(
+  projectPath: string,
+  configuredEditor?: string,
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<void> {
+  const preferredEditor = configuredEditor?.trim() || getEnvEditor(env);
+  if (preferredEditor) {
+    const parsed = parseEditorCommand(preferredEditor);
+    await spawnDetached(parsed.command, [...parsed.args, projectPath]);
+    return;
+  }
+
+  const fallback = getSystemOpenCommand(projectPath);
+  await spawnDetached(fallback.command, fallback.args);
+}

package/src/lib/git.ts

@@ -1,12 +1,12 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 
 const execFileAsync = promisify(execFile);
 
 async function runGit(cwd: string, args: string[]): Promise<string | null> {
   try {
-    const { stdout } = await execFileAsync('git', ['-C', cwd, ...args], {
-      encoding: 'utf8',
+    const { stdout } = await execFileAsync("git", ["-C", cwd, ...args], {
+      encoding: "utf8",
     });
     return stdout.trim();
   } catch {
@@ -14,18 +14,28 @@ async function runGit(cwd: string, args: string[]): Promise<string | null> {
   }
 }
 
-export async function getFirstCommitDate(cwd: string): Promise<string | undefined> {
-  const output = await runGit(cwd, ['log', '--reverse', '--format=%cI', '-n', '1']);
+export async function getFirstCommitDate(
+  cwd: string,
+): Promise<string | undefined> {
+  const output = await runGit(cwd, [
+    "log",
+    "--max-parents=0",
+    "--format=%cd",
+    "--date=iso-strict",
+    "HEAD",
+  ]);
   return output || undefined;
 }
 
-export async function getDirtyStatus(cwd: string): Promise<boolean | undefined> {
-  const output = await runGit(cwd, ['status', '--porcelain']);
+export async function getDirtyStatus(
+  cwd: string,
+): Promise<boolean | undefined> {
+  const output = await runGit(cwd, ["status", "--porcelain"]);
   if (output === null) return undefined;
   return output.length > 0;
 }
 
 export async function isInsideGitRepo(cwd: string): Promise<boolean> {
-  const output = await runGit(cwd, ['rev-parse', '--is-inside-work-tree']);
-  return output === 'true';
+  const output = await runGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  return output === "true";
 }