bet-cli 0.1.2 → 0.1.3

package/README.md

@@ -1,3 +1,13 @@
+```
+  ██
+  ██
+  ████████████
+             ██
+             ████████
+                    ╲╲
+                   ╲╲
+```
+
 # bet
 
 Keep your house in order. Explore and jump between local projects.
@@ -91,7 +101,7 @@ Then Tab-complete the slug argument after `bet go `, `bet path `, or `bet info `
 - **`bet update`**: Scan configured roots and rebuild the project index.
   - **First-time setup**: `bet update --roots "$HOME/code,$HOME/work"`
   - If you pass `--roots` when you already have roots in config, you will be warned and must confirm (or use `--force` when not in a TTY).
-  - **Optional**: `--cron` installs an hourly `crontab` entry that runs `bet update` and logs output to your bet config directory
+  - **Optional**: `--cron [frequency]` — install a `crontab` entry that runs `bet update` on a schedule. Use Nm (1–59), Nh (1–24), or Nd (1–31), e.g. `--cron 5m`, `--cron 1h` (default if omitted), `--cron 2d`. Use `--cron 0` or `--cron false` to remove the cron. Cron stdout/stderr are appended to `~/.config/bet/cron-update.log`; structured logs go to the main log file (see [Logging](#logging)).
 - **`bet list`**: List indexed projects (interactive by default).
   - **`--plain`**: non-interactive output
   - **`--json`**: machine-readable output
@@ -111,10 +121,20 @@ bet stores its data in:
 
 - **Config dir**: `~/.config/bet/` (or `$XDG_CONFIG_HOME/bet/`)
 - **Roots**: `config.json` — each root is `{ "path": "/absolute/path", "name": "display-name" }`. The name defaults to the top folder name and is used when listing/grouping projects.
+- **slugParentFolders** (optional): In `config.json`, an array of folder names. When a discovered project path ends in one of these (e.g. `src` or `app`), the project slug is taken from the parent directory name instead. Default in code is `["src", "app"]` when the key is not set.
 - **Project index**: `projects.json`
 
 These are plain JSON files—easy to inspect, back up, or edit.
 
+### Logging
+
+bet writes a structured log file for debugging, especially when `bet update` runs from cron:
+
+- **macOS**: `~/Library/Logs/bet/bet.log`
+- **Linux**: `~/.local/state/bet/bet.log` (or `$XDG_STATE_HOME/bet/bet.log`)
+
+Each line is timestamped and includes a level (`DEBUG`, `INFO`, `WARN`, `ERROR`). Set `BET_LOG_LEVEL=debug` for verbose output when troubleshooting (e.g. in your cron environment). When run from cron, stdout/stderr are also captured in `~/.config/bet/cron-update.log`; the main log file is the structured, level-based log.
+
 ### Advanced filtering with `--json`
 
 You can combine `bet list --json` with [jq](https://stedolan.github.io/jq/) for powerful, scriptable project filtering. Here are some practical examples:

package/dist/commands/completion.js

@@ -9,6 +9,7 @@ const SUBCOMMANDS = [
     "path",
     "shell",
     "completion",
+    "ignore",
 ];
 function zshScript() {
     const slugCommandsPattern = SLUG_COMMANDS.join("|");
@@ -24,6 +25,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/dist/commands/ignore.js

@@ -0,0 +1,78 @@
+import { readConfig, writeConfig } from "../lib/config.js";
+import { normalizeAbsolute, isSubpath } from "../utils/paths.js";
+function isPathUnderRoot(filePath, rootPath) {
+    return filePath === rootPath || isSubpath(filePath, rootPath);
+}
+function isPathUnderAnyRoot(filePath, rootPaths) {
+    return rootPaths.some((rootPath) => isPathUnderRoot(filePath, rootPath));
+}
+export function registerIgnore(program) {
+    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, options) => {
+        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) => {
+        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/dist/commands/update.js

@@ -2,10 +2,12 @@ import path from "node:path";
 import readline from "node:readline";
 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 { isInsideGitRepo } from "../lib/git.js";
+import { log } from "../lib/logger.js";
 function parseRoots(value) {
     if (!value)
         return undefined;
@@ -24,9 +26,11 @@ export function willOverrideRoots(providedRootConfigs, configRoots) {
     return !!(providedRootConfigs !== undefined &&
         configRoots.length > 0);
 }
-function projectSlug(pathName) {
+const DEFAULT_SLUG_PARENT_FOLDERS = ["src", "app"];
+export { DEFAULT_SLUG_PARENT_FOLDERS };
+export function projectSlug(pathName, slugParentFolders) {
     const folderName = path.basename(pathName);
-    if (folderName === "src" || folderName === "app") {
+    if (slugParentFolders.includes(folderName)) {
         return path.basename(path.dirname(pathName));
     }
     return folderName;
@@ -52,89 +56,144 @@ export function registerUpdate(program) {
         .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")
+        .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) => {
-        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) {
-            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;
-        }
-        const willOverride = willOverrideRoots(providedRootConfigs, config.roots);
-        if (willOverride) {
-            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) {
-                    process.stderr.write("Error: Refusing to override without confirmation. Run interactively or use --force.\n");
-                    process.exitCode = 1;
-                    return;
-                }
+        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;
             }
-            else {
-                const confirmed = await promptYesNo("Continue?", true);
-                if (!confirmed) {
-                    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);
-        const candidates = await scanRoots(rootPaths);
-        const projects = {};
-        for (const candidate of candidates) {
-            const hasGit = await isInsideGitRepo(candidate.path);
-            const auto = await computeMetadata(candidate.path, hasGit);
-            const slug = projectSlug(candidate.path);
-            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 = {
-                id: candidate.path,
-                slug,
-                name: slug,
-                path: candidate.path,
-                root: candidate.root,
-                rootName,
-                hasGit,
-                hasReadme: candidate.hasReadme,
-                auto,
-                user: existing?.user,
+            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 = {};
+            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 = {
+                    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 = {
+                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 }),
             };
-            projects[candidate.path] = project;
+            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`);
+                }
+                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;
+                        }
+                    }
+                }
+            }
         }
-        const nextConfig = {
-            version: config.version ?? 1,
-            roots: rootsResolved,
-            projects,
-        };
-        await writeConfig(nextConfig);
-        process.stdout.write("Indexed " +
-            Object.keys(projects).length +
-            " projects from " +
-            rootsResolved.length +
-            " root(s).\n");
-        if (options.cron) {
-            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");
+        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/dist/index.js

@@ -8,11 +8,12 @@ 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.0");
+    .version("0.1.2");
 registerUpdate(program);
 registerList(program);
 registerSearch(program);
@@ -21,4 +22,5 @@ registerGo(program);
 registerPath(program);
 registerShell(program);
 registerCompletion(program);
+registerIgnore(program);
 program.parseAsync(process.argv);

package/dist/lib/config.js

@@ -42,15 +42,39 @@ function normalizeRoots(parsedRoots) {
     }
     return result;
 }
+function normalizeIgnores(parsed) {
+    if (!Array.isArray(parsed))
+        return undefined;
+    const list = parsed.filter((x) => typeof x === "string");
+    return list;
+}
+function normalizeSlugParentFolders(parsed) {
+    if (!Array.isArray(parsed))
+        return undefined;
+    const list = parsed.filter((x) => typeof x === "string" && x.trim() !== "").map((x) => x.trim());
+    return list.length === 0 ? undefined : list;
+}
+function normalizeIgnoredPaths(parsed) {
+    if (!Array.isArray(parsed))
+        return undefined;
+    const list = parsed.filter((x) => typeof x === "string").map((x) => normalizeAbsolute(x));
+    return list.length === 0 ? undefined : list;
+}
 async function readAppConfig() {
     try {
         const raw = await fs.readFile(CONFIG_PATH, "utf8");
         const parsed = JSON.parse(raw);
         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) {
@@ -108,6 +132,9 @@ export async function writeConfig(config) {
     const 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 = {
         projects: config.projects,

package/dist/lib/cron.js

@@ -2,16 +2,67 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { getConfigPath } from "./config.js";
-const CRON_MARKER = "# bet:update hourly";
+const CRON_MARKER = "# bet:update";
 const WRAPPER_SCRIPT_NAME = "bet-update-cron.sh";
 const LOG_FILE_NAME = "cron-update.log";
+const SCHEDULE_REGEX = /^(\d+)(m|h|d)$/i;
+const MINUTES_MIN = 1;
+const MINUTES_MAX = 59;
+const HOURS_MIN = 1;
+const HOURS_MAX = 24;
+const DAYS_MIN = 1;
+const DAYS_MAX = 31;
+/**
+ * Parses a schedule string (e.g. "5m", "2h", "7d") and validates ranges.
+ * @throws Error if format is invalid or value is out of range (m: 1-59, h: 1-24, d: 1-31).
+ */
+export function parseCronSchedule(schedule) {
+    const trimmed = schedule.trim().toLowerCase();
+    const match = trimmed.match(SCHEDULE_REGEX);
+    if (!match) {
+        throw new Error(`Invalid cron schedule "${schedule}". Use Nm (1-59), Nh (1-24), or Nd (1-31). Examples: 5m, 1h, 7d. Use 0 or false to disable.`);
+    }
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    if (unit === "m" && (value < MINUTES_MIN || value > MINUTES_MAX)) {
+        throw new Error(`Invalid minutes: ${value}. Use 1-59 for Nm (e.g. 5m, 30m).`);
+    }
+    if (unit === "h" && (value < HOURS_MIN || value > HOURS_MAX)) {
+        throw new Error(`Invalid hours: ${value}. Use 1-24 for Nh (e.g. 1h, 12h). Use 24h for once per day.`);
+    }
+    if (unit === "d" && (value < DAYS_MIN || value > DAYS_MAX)) {
+        throw new Error(`Invalid days: ${value}. Use 1-31 for Nd (e.g. 1d, 7d).`);
+    }
+    return { value, unit };
+}
+/**
+ * Converts a parsed schedule to a 5-field cron expression (minute hour dom month dow).
+ */
+export function scheduleToCronExpression(parsed) {
+    const { value, unit } = parsed;
+    if (unit === "m") {
+        return `*/${value} * * * *`;
+    }
+    if (unit === "h") {
+        if (value === 24) {
+            return "0 0 * * *";
+        }
+        return `0 */${value} * * *`;
+    }
+    // unit === "d"
+    return `0 0 */${value} * *`;
+}
 /**
  * Writes a wrapper script and installs/updates a per-user crontab entry
- * so that `bet update` runs every hour. Idempotent: re-running replaces
- * the existing bet cron block.
+ * so that `bet update` runs at the given schedule. Idempotent: re-running
+ * replaces the existing bet cron block (single cron only).
+ * @throws Error if schedule is invalid (see parseCronSchedule).
+ * @returns Paths to the wrapper script and log file for user reference.
  */
-export async function installHourlyUpdateCron(options) {
-    const { nodePath, entryScriptPath } = options;
+export async function installUpdateCron(options) {
+    const { nodePath, entryScriptPath, schedule } = options;
+    const parsed = parseCronSchedule(schedule);
+    const cronExpression = scheduleToCronExpression(parsed);
     const configDir = path.dirname(getConfigPath());
     await fs.mkdir(configDir, { recursive: true });
     const wrapperPath = path.join(configDir, WRAPPER_SCRIPT_NAME);
@@ -22,7 +73,7 @@ export async function installHourlyUpdateCron(options) {
     ].join("\n");
     await fs.writeFile(wrapperPath, scriptBody + "\n", "utf8");
     await fs.chmod(wrapperPath, 0o755);
-    const scheduleLine = `0 * * * * ${wrapperPath}`;
+    const scheduleLine = `${cronExpression} ${wrapperPath}`;
     const betBlock = [CRON_MARKER, scheduleLine].join("\n");
     const crontabL = spawnSync("crontab", ["-l"], {
         encoding: "utf8",
@@ -70,4 +121,62 @@ export async function installHourlyUpdateCron(options) {
         const err = crontabWrite.stderr || crontabWrite.stdout || "unknown";
         throw new Error(`crontab install failed: ${err}`);
     }
+    return { wrapperPath, logPath };
+}
+/**
+ * Removes the bet update cron entry from the user's crontab (if present).
+ */
+export async function uninstallUpdateCron() {
+    const crontabL = spawnSync("crontab", ["-l"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    let existingCrontab = "";
+    if (crontabL.status === 0 && crontabL.stdout) {
+        existingCrontab = crontabL.stdout;
+    }
+    if (crontabL.status !== 0 && crontabL.stderr && !crontabL.stderr.includes("no crontab")) {
+        throw new Error(`crontab -l failed: ${crontabL.stderr}`);
+    }
+    const lines = existingCrontab.split("\n");
+    const out = [];
+    let skipNext = false;
+    for (const line of lines) {
+        if (skipNext) {
+            skipNext = false;
+            continue;
+        }
+        if (line === CRON_MARKER) {
+            skipNext = true;
+            continue;
+        }
+        out.push(line);
+    }
+    const newCrontab = out.length > 0 ? out.join("\n").replace(/\n*$/, "") + "\n" : "";
+    if (newCrontab === "") {
+        spawnSync("crontab", ["-r"], { stdio: "pipe" });
+        return;
+    }
+    const crontabWrite = spawnSync("crontab", ["-"], {
+        encoding: "utf8",
+        input: newCrontab,
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    if (crontabWrite.status !== 0) {
+        const err = crontabWrite.stderr || crontabWrite.stdout || "unknown";
+        throw new Error(`crontab update failed: ${err}`);
+    }
+}
+/**
+ * Returns a human-readable label for a parsed schedule (e.g. "every 5 minutes").
+ */
+export function formatScheduleLabel(parsed) {
+    const { value, unit } = parsed;
+    if (unit === "m") {
+        return value === 1 ? "every minute" : `every ${value} minutes`;
+    }
+    if (unit === "h") {
+        return value === 1 ? "every hour" : `every ${value} hours`;
+    }
+    return value === 1 ? "every day" : `every ${value} days`;
 }

package/dist/lib/ignore.js

@@ -1,3 +1,4 @@
+import { isSubpath } from "../utils/paths.js";
 export const DEFAULT_IGNORES = [
     "**/node_modules/**",
     "**/.git/**",
@@ -9,3 +10,11 @@ export const DEFAULT_IGNORES = [
     "**/.venv/**",
     "**/venv/**",
 ];
+export function getEffectiveIgnores(config) {
+    return config.ignores !== undefined ? config.ignores : DEFAULT_IGNORES;
+}
+export function isPathIgnored(projectPath, ignoredPaths) {
+    if (ignoredPaths.length === 0)
+        return false;
+    return ignoredPaths.some((ip) => projectPath === ip || isSubpath(projectPath, ip));
+}

package/dist/lib/log-dir.js

@@ -0,0 +1,22 @@
+import path from "node:path";
+import os from "node:os";
+const LOG_FILE_NAME = "bet.log";
+/**
+ * Returns the directory where bet writes its log file.
+ * - macOS: ~/Library/Logs/bet
+ * - Linux / others: $XDG_STATE_HOME/bet or ~/.local/state/bet
+ */
+export function getLogDir() {
+    const homedir = os.homedir();
+    if (process.platform === "darwin") {
+        return path.join(homedir, "Library", "Logs", "bet");
+    }
+    const stateHome = process.env.XDG_STATE_HOME ?? path.join(homedir, ".local", "state");
+    return path.join(stateHome, "bet");
+}
+/**
+ * Returns the full path to the log file (e.g. getLogDir()/bet.log).
+ */
+export function getLogFilePath() {
+    return path.join(getLogDir(), LOG_FILE_NAME);
+}