bet-cli 0.1.2 → 0.1.3

package/dist/lib/logger.js

@@ -0,0 +1,80 @@
+import fs from "node:fs";
+import { getLogDir, getLogFilePath } from "./log-dir.js";
+const LEVELS = ["debug", "info", "warn", "error"];
+const LEVEL_ORDER = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+function parseLogLevel() {
+    const raw = process.env.BET_LOG_LEVEL?.trim().toLowerCase();
+    if (raw && LEVELS.includes(raw)) {
+        return raw;
+    }
+    return "info";
+}
+let minLevelOrder = LEVEL_ORDER[parseLogLevel()];
+let fileStream = null;
+function ensureStream() {
+    if (fileStream != null) {
+        return fileStream;
+    }
+    const logDir = getLogDir();
+    fs.mkdirSync(logDir, { recursive: true });
+    const logPath = getLogFilePath();
+    fileStream = fs.createWriteStream(logPath, { flags: "a" });
+    return fileStream;
+}
+function formatLine(level, message, stack) {
+    const ts = new Date().toISOString();
+    let line = `${ts} ${level.toUpperCase()} ${message}`;
+    if (stack) {
+        line += "\n" + stack;
+    }
+    return line + "\n";
+}
+function shouldLog(level) {
+    return LEVEL_ORDER[level] >= minLevelOrder;
+}
+function write(level, message, stack) {
+    if (!shouldLog(level)) {
+        return;
+    }
+    const line = formatLine(level, message, stack);
+    try {
+        ensureStream().write(line);
+    }
+    catch {
+        // Avoid throwing from logger; best-effort only
+    }
+    if (process.stderr.isTTY) {
+        process.stderr.write(line);
+    }
+}
+export const log = {
+    debug(msg, ...args) {
+        const message = args.length > 0 ? `${msg} ${args.map(String).join(" ")}` : msg;
+        write("debug", message);
+    },
+    info(msg, ...args) {
+        const message = args.length > 0 ? `${msg} ${args.map(String).join(" ")}` : msg;
+        write("info", message);
+    },
+    warn(msg, ...args) {
+        const message = args.length > 0 ? `${msg} ${args.map(String).join(" ")}` : msg;
+        write("warn", message);
+    },
+    error(errOrMsg, ...args) {
+        if (errOrMsg instanceof Error) {
+            const message = errOrMsg.message;
+            const stack = errOrMsg.stack;
+            write("error", message, stack);
+            return;
+        }
+        const message = args.length > 0
+            ? `${String(errOrMsg)} ${args.map(String).join(" ")}`
+            : String(errOrMsg);
+        write("error", message);
+    },
+};

package/dist/lib/metadata.js

@@ -1,15 +1,14 @@
 import fg from 'fast-glob';
-import { DEFAULT_IGNORES } from './ignore.js';
 import { getDirtyStatus, getFirstCommitDate } from './git.js';
 import { readReadmeDescription } from './readme.js';
-export async function computeMetadata(projectPath, hasGit) {
+export async function computeMetadata(projectPath, hasGit, ignores) {
     const nowIso = new Date().toISOString();
     const entries = await fg('**/*', {
         cwd: projectPath,
         dot: true,
         onlyFiles: true,
         followSymbolicLinks: false,
-        ignore: DEFAULT_IGNORES,
+        ignore: ignores,
         stats: true,
     });
     let oldest;

package/dist/lib/scan.js

@@ -1,14 +1,8 @@
 import path from "node:path";
 import fg from "fast-glob";
-import { DEFAULT_IGNORES } from "./ignore.js";
 import { isSubpath } from "../utils/paths.js";
 import { isInsideGitRepo } from "./git.js";
-const README_PATTERNS = [
-    "**/README.md",
-    "**/readme.md",
-    "**/Readme.md",
-    "**/README.MD",
-];
+const README_PATTERNS = ["**/README.md", "**/readme.txt"];
 function resolveProjectRoot(matchPath) {
     const container = path.dirname(matchPath);
     // if (
@@ -36,11 +30,11 @@ function addCandidate(map, projectPath, root, flags) {
     }
     map.set(projectPath, next);
 }
-export async function scanRoots(roots) {
+export async function scanRoots(roots, ignores) {
     const candidates = new Map();
     for (const root of roots) {
         // Exclude .git/** from ignores when scanning for .git directories
-        const gitIgnores = DEFAULT_IGNORES.filter((pattern) => pattern !== "**/.git/**");
+        const gitIgnores = ignores.filter((pattern) => pattern !== "**/.git/**");
         const gitMatches = await fg("**/.git", {
             cwd: root,
             dot: true,
@@ -61,7 +55,8 @@ export async function scanRoots(roots) {
             dot: true,
             onlyFiles: true,
             followSymbolicLinks: false,
-            ignore: DEFAULT_IGNORES,
+            ignore: ignores,
+            caseSensitiveMatch: false,
         });
         for (const match of readmeMatches) {
             const absMatch = path.join(root, match);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bet-cli",
   "description": "Explore and jump between local projects.",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "author": "Chris Mckenzie",
   "license": "Apache-2.0",
   "repository": {

package/src/commands/completion.ts

@@ -11,6 +11,7 @@ const SUBCOMMANDS = [
   "path",
   "shell",
   "completion",
+  "ignore",
 ];
 
 function zshScript(): string {
@@ -27,6 +28,7 @@ _bet() {
     'path:Print project path'
     'shell:Print shell integration'
     'completion:Print shell completion script'
+    'ignore:Manage ignored project paths'
   )
 
   if (( CURRENT == 2 )); then

package/src/commands/ignore.ts

@@ -0,0 +1,93 @@
+import { Command } from "commander";
+import { readConfig, writeConfig } from "../lib/config.js";
+import { normalizeAbsolute, isSubpath } from "../utils/paths.js";
+
+function isPathUnderRoot(filePath: string, rootPath: string): boolean {
+  return filePath === rootPath || isSubpath(filePath, rootPath);
+}
+
+function isPathUnderAnyRoot(filePath: string, rootPaths: string[]): boolean {
+  return rootPaths.some((rootPath) => isPathUnderRoot(filePath, rootPath));
+}
+
+export function registerIgnore(program: Command): void {
+  const ignoreCmd = program
+    .command("ignore")
+    .description("Manage ignored project paths (excluded from index)");
+
+  ignoreCmd
+    .command("add [filepath]")
+    .description("Add a path to the ignore list (must be under a configured root)")
+    .option("--this", "Ignore the current folder")
+    .action(async (filepath: string | undefined, options: { this?: boolean }) => {
+      const pathToAdd = options.this ? process.cwd() : filepath;
+      if (pathToAdd === undefined || pathToAdd === "") {
+        process.stderr.write("Error: Provide a path or use --this to ignore the current folder.\n");
+        process.exitCode = 1;
+        return;
+      }
+      const normalized = normalizeAbsolute(pathToAdd);
+      const config = await readConfig();
+
+      if (!config.roots.length) {
+        process.stderr.write("Error: No roots configured. Add roots first (e.g. bet update --roots /path/to/code).\n");
+        process.exitCode = 1;
+        return;
+      }
+
+      const rootPaths = config.roots.map((r) => r.path);
+      if (!isPathUnderAnyRoot(normalized, rootPaths)) {
+        process.stderr.write(
+          `Error: Path must be under a configured root.\n  Path: ${normalized}\n  Roots: ${rootPaths.join(", ")}\n`,
+        );
+        process.exitCode = 1;
+        return;
+      }
+
+      const ignoredPaths = config.ignoredPaths ?? [];
+      if (ignoredPaths.includes(normalized)) {
+        process.stdout.write(`Already ignored: ${normalized}\n`);
+        return;
+      }
+
+      const nextIgnoredPaths = [...ignoredPaths, normalized];
+      await writeConfig({
+        ...config,
+        ignoredPaths: nextIgnoredPaths,
+      });
+      process.stdout.write(`Ignored: ${normalized}\n`);
+    });
+
+  ignoreCmd
+    .command("rm <filepath>")
+    .description("Remove a path from the ignore list")
+    .action(async (filepath: string) => {
+      const normalized = normalizeAbsolute(filepath);
+      const config = await readConfig();
+      const ignoredPaths = config.ignoredPaths ?? [];
+      const index = ignoredPaths.indexOf(normalized);
+
+      if (index === -1) {
+        process.stdout.write(`Not in ignore list: ${normalized}\n`);
+        return;
+      }
+
+      const nextIgnoredPaths = ignoredPaths.filter((_, i) => i !== index);
+      await writeConfig({
+        ...config,
+        ignoredPaths: nextIgnoredPaths.length > 0 ? nextIgnoredPaths : undefined,
+      });
+      process.stdout.write(`Removed from ignore list: ${normalized}\n`);
+    });
+
+  ignoreCmd
+    .command("list")
+    .description("List ignored paths")
+    .action(async () => {
+      const config = await readConfig();
+      const ignoredPaths = config.ignoredPaths ?? [];
+      for (const p of ignoredPaths) {
+        process.stdout.write(`${p}\n`);
+      }
+    });
+}

package/src/commands/update.ts

@@ -3,11 +3,13 @@ import readline from "node:readline";
 import { Command } from "commander";
 import { readConfig, resolveRoots, writeConfig } from "../lib/config.js";
 import { normalizeAbsolute } from "../utils/paths.js";
-import { installHourlyUpdateCron } 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";
 import { Config, Project, RootConfig } from "../lib/types.js";
 import { isInsideGitRepo } from "../lib/git.js";
+import { log } from "../lib/logger.js";
 
 function parseRoots(value?: string): string[] | undefined {
   if (!value) return undefined;
@@ -34,9 +36,12 @@ export function willOverrideRoots(
   );
 }
 
-function projectSlug(pathName: string): string {
+const DEFAULT_SLUG_PARENT_FOLDERS = ["src", "app"];
+
+export { DEFAULT_SLUG_PARENT_FOLDERS };
+export function projectSlug(pathName: string, slugParentFolders: string[]): string {
   const folderName = path.basename(pathName);
-  if (folderName === "src" || folderName === "app") {
+  if (slugParentFolders.includes(folderName)) {
     return path.basename(path.dirname(pathName));
   }
   return folderName;
@@ -64,8 +69,9 @@ 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", "Install an hourly cron job to run bet update")
-    .action(async (options: { roots?: string; force?: boolean; cron?: boolean }) => {
+    .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
@@ -75,6 +81,7 @@ export function registerUpdate(program: Command): void {
       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",
@@ -86,6 +93,7 @@ export function registerUpdate(program: Command): void {
       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: " +
@@ -96,6 +104,7 @@ export function registerUpdate(program: Command): void {
         );
         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",
             );
@@ -105,6 +114,7 @@ export function registerUpdate(program: Command): void {
         } else {
           const confirmed = await promptYesNo("Continue?", true);
           if (!confirmed) {
+            log.info("update aborted by user");
             process.stderr.write("Aborted.\n");
             return;
           }
@@ -113,13 +123,21 @@ export function registerUpdate(program: Command): void {
 
       const rootsResolved = resolveRoots(rootsToUse);
       const rootPaths = rootsResolved.map((r) => r.path);
-      const candidates = await scanRoots(rootPaths);
+      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 candidates) {
+      for (const candidate of filteredCandidates) {
         const hasGit = await isInsideGitRepo(candidate.path);
-        const auto = await computeMetadata(candidate.path, hasGit);
-        const slug = projectSlug(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);
@@ -144,27 +162,72 @@ export function registerUpdate(program: Command): void {
         version: config.version ?? 1,
         roots: rootsResolved,
         projects,
+        ...(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 " +
-          Object.keys(projects).length +
+          projectCount +
           " projects from " +
-          rootsResolved.length +
+          rootCount +
           " root(s).\n",
       );
 
-      if (options.cron) {
+      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");
-        await installHourlyUpdateCron({
-          nodePath: process.execPath,
-          entryScriptPath,
-        });
-        process.stdout.write("Installed hourly cron job for bet update.\n");
+        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`,
+          );
+        } 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;
       }
     });
 }

package/src/index.ts

@@ -8,13 +8,14 @@ import { registerGo } from "./commands/go.js";
 import { registerPath } from "./commands/path.js";
 import { registerShell } from "./commands/shell.js";
 import { registerCompletion } from "./commands/completion.js";
+import { registerIgnore } from "./commands/ignore.js";
 
 const program = new Command();
 
 program
   .name("bet")
   .description("Explore and jump between local projects.")
-  .version("0.1.2");
+  .version("0.1.3");
 
 registerUpdate(program);
 registerList(program);
@@ -24,5 +25,6 @@ registerGo(program);
 registerPath(program);
 registerShell(program);
 registerCompletion(program);
+registerIgnore(program);
 
 program.parseAsync(process.argv);

package/src/lib/config.ts

@@ -50,15 +50,39 @@ function normalizeRoots(parsedRoots: unknown): RootConfig[] {
   return result;
 }
 
+function normalizeIgnores(parsed: unknown): string[] | undefined {
+  if (!Array.isArray(parsed)) return undefined;
+  const list = parsed.filter((x): x is string => typeof x === "string");
+  return list;
+}
+
+function normalizeSlugParentFolders(parsed: unknown): string[] | undefined {
+  if (!Array.isArray(parsed)) return undefined;
+  const list = parsed.filter((x): x is string => typeof x === "string" && x.trim() !== "").map((x) => x.trim());
+  return list.length === 0 ? undefined : list;
+}
+
+function normalizeIgnoredPaths(parsed: unknown): string[] | undefined {
+  if (!Array.isArray(parsed)) return undefined;
+  const list = parsed.filter((x): x is string => typeof x === "string").map((x) => normalizeAbsolute(x));
+  return list.length === 0 ? undefined : list;
+}
+
 async function readAppConfig(): Promise<AppConfig> {
   try {
     const raw = await fs.readFile(CONFIG_PATH, "utf8");
-    const parsed = JSON.parse(raw) as { version?: number; roots?: unknown };
+    const parsed = JSON.parse(raw) as { version?: number; roots?: unknown; ignores?: unknown; ignoredPaths?: unknown; slugParentFolders?: unknown };
     const roots = normalizeRoots(parsed.roots ?? []);
+    const ignores = normalizeIgnores(parsed.ignores);
+    const ignoredPaths = normalizeIgnoredPaths(parsed.ignoredPaths);
+    const slugParentFolders = normalizeSlugParentFolders(parsed.slugParentFolders);
     return {
       ...DEFAULT_APP_CONFIG,
       version: parsed.version ?? 1,
       roots,
+      ...(ignores !== undefined && { ignores }),
+      ...(ignoredPaths !== undefined && { ignoredPaths }),
+      ...(slugParentFolders !== undefined && { slugParentFolders }),
     };
   } catch (error) {
     return { ...DEFAULT_APP_CONFIG };
@@ -120,6 +144,9 @@ export async function writeConfig(config: Config): Promise<void> {
   const appConfig: AppConfig = {
     version: config.version,
     roots: config.roots,
+    ...(config.ignores !== undefined && { ignores: config.ignores }),
+    ...(config.ignoredPaths !== undefined && { ignoredPaths: config.ignoredPaths }),
+    ...(config.slugParentFolders !== undefined && { slugParentFolders: config.slugParentFolders }),
   };
   const projectsConfig: ProjectsConfig = {
     projects: config.projects,