bet-cli 0.1.2 → 0.1.3

package/src/lib/cron.ts

@@ -3,26 +3,101 @@ 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";
 
-export type InstallHourlyUpdateCronOptions = {
+const SCHEDULE_REGEX = /^(\d+)(m|h|d)$/i;
+
+export type CronScheduleUnit = "m" | "h" | "d";
+
+export type ParsedCronSchedule = {
+  value: number;
+  unit: CronScheduleUnit;
+};
+
+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: string): ParsedCronSchedule {
+  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] as CronScheduleUnit;
+
+  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: ParsedCronSchedule): string {
+  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} * *`;
+}
+
+export type InstallUpdateCronOptions = {
   /** Absolute path to the Node binary (e.g. process.execPath). */
   nodePath: string;
   /** Absolute path to the bet CLI entry script (e.g. dist/index.js). */
   entryScriptPath: string;
+  /** Schedule string: Nm (1-59), Nh (1-24), Nd (1-31). Example: "5m", "1h", "7d". */
+  schedule: string;
 };
 
 /**
  * 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: InstallHourlyUpdateCronOptions,
-): Promise<void> {
-  const { nodePath, entryScriptPath } = options;
+export async function installUpdateCron(
+  options: InstallUpdateCronOptions,
+): Promise<{ wrapperPath: string; logPath: string }> {
+  const { nodePath, entryScriptPath, schedule } = options;
+  const parsed = parseCronSchedule(schedule);
+  const cronExpression = scheduleToCronExpression(parsed);
+
   const configDir = path.dirname(getConfigPath());
   await fs.mkdir(configDir, { recursive: true });
 
@@ -37,7 +112,7 @@ export async function installHourlyUpdateCron(
   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"], {
@@ -93,4 +168,72 @@ export async function installHourlyUpdateCron(
     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(): Promise<void> {
+  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: string[] = [];
+  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: ParsedCronSchedule): string {
+  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/src/lib/ignore.ts

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

package/src/lib/log-dir.ts

@@ -0,0 +1,26 @@
+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(): string {
+  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(): string {
+  return path.join(getLogDir(), LOG_FILE_NAME);
+}

package/src/lib/logger.ts

@@ -0,0 +1,92 @@
+import fs from "node:fs";
+import { getLogDir, getLogFilePath } from "./log-dir.js";
+
+const LEVELS = ["debug", "info", "warn", "error"] as const;
+type LogLevel = (typeof LEVELS)[number];
+
+const LEVEL_ORDER: Record<LogLevel, number> = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+};
+
+function parseLogLevel(): LogLevel {
+  const raw = process.env.BET_LOG_LEVEL?.trim().toLowerCase();
+  if (raw && LEVELS.includes(raw as LogLevel)) {
+    return raw as LogLevel;
+  }
+  return "info";
+}
+
+let minLevelOrder: number = LEVEL_ORDER[parseLogLevel()];
+let fileStream: fs.WriteStream | null = null;
+
+function ensureStream(): fs.WriteStream {
+  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: LogLevel, message: string, stack?: string): string {
+  const ts = new Date().toISOString();
+  let line = `${ts} ${level.toUpperCase()} ${message}`;
+  if (stack) {
+    line += "\n" + stack;
+  }
+  return line + "\n";
+}
+
+function shouldLog(level: LogLevel): boolean {
+  return LEVEL_ORDER[level] >= minLevelOrder;
+}
+
+function write(level: LogLevel, message: string, stack?: string): void {
+  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: string, ...args: unknown[]): void {
+    const message = args.length > 0 ? `${msg} ${args.map(String).join(" ")}` : msg;
+    write("debug", message);
+  },
+
+  info(msg: string, ...args: unknown[]): void {
+    const message = args.length > 0 ? `${msg} ${args.map(String).join(" ")}` : msg;
+    write("info", message);
+  },
+
+  warn(msg: string, ...args: unknown[]): void {
+    const message = args.length > 0 ? `${msg} ${args.map(String).join(" ")}` : msg;
+    write("warn", message);
+  },
+
+  error(errOrMsg: Error | string, ...args: unknown[]): void {
+    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/src/lib/metadata.ts

@@ -1,10 +1,9 @@
 import fg from 'fast-glob';
-import { DEFAULT_IGNORES } from './ignore.js';
 import { ProjectAutoMetadata } from './types.js';
 import { getDirtyStatus, getFirstCommitDate } from './git.js';
 import { readReadmeDescription } from './readme.js';
 
-export async function computeMetadata(projectPath: string, hasGit: boolean): Promise<ProjectAutoMetadata> {
+export async function computeMetadata(projectPath: string, hasGit: boolean, ignores: string[]): Promise<ProjectAutoMetadata> {
   const nowIso = new Date().toISOString();
 
   const entries = await fg('**/*', {
@@ -12,7 +11,7 @@ export async function computeMetadata(projectPath: string, hasGit: boolean): Pro
     dot: true,
     onlyFiles: true,
     followSymbolicLinks: false,
-    ignore: DEFAULT_IGNORES,
+    ignore: ignores,
     stats: true,
   });
 

package/src/lib/scan.ts

@@ -1,16 +1,10 @@
 import path from "node:path";
 import fg from "fast-glob";
 import { ProjectCandidate } from "./types.js";
-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: string): string {
   const container = path.dirname(matchPath);
@@ -49,12 +43,12 @@ function addCandidate(
   map.set(projectPath, next);
 }
 
-export async function scanRoots(roots: string[]): Promise<ProjectCandidate[]> {
+export async function scanRoots(roots: string[], ignores: string[]): Promise<ProjectCandidate[]> {
   const candidates = new Map<string, ProjectCandidate>();
 
   for (const root of roots) {
     // Exclude .git/** from ignores when scanning for .git directories
-    const gitIgnores = DEFAULT_IGNORES.filter(
+    const gitIgnores = ignores.filter(
       (pattern) => pattern !== "**/.git/**",
     );
     const gitMatches = await fg("**/.git", {
@@ -78,7 +72,8 @@ export async function scanRoots(roots: string[]): Promise<ProjectCandidate[]> {
       dot: true,
       onlyFiles: true,
       followSymbolicLinks: false,
-      ignore: DEFAULT_IGNORES,
+      ignore: ignores,
+      caseSensitiveMatch: false,
     });
 
     for (const match of readmeMatches) {

package/src/lib/types.ts

@@ -33,6 +33,9 @@ export type RootConfig = {
 export type AppConfig = {
   version: number;
   roots: RootConfig[];
+  ignores?: string[];
+  ignoredPaths?: string[];
+  slugParentFolders?: string[];
 };
 
 export type ProjectsConfig = {
@@ -42,6 +45,9 @@ export type ProjectsConfig = {
 export type Config = {
   version: number;
   roots: RootConfig[];
+  ignores?: string[];
+  ignoredPaths?: string[];
+  slugParentFolders?: string[];
   projects: Record<string, Project>;
 };
 

package/tests/config.test.ts

@@ -1,7 +1,8 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import path from "node:path";
 import fs from "node:fs/promises";
-import { readConfig, resolveRoots, getConfigPath, getProjectsPath } from "../src/lib/config.js";
+import { readConfig, resolveRoots, getConfigPath, getProjectsPath, writeConfig } from "../src/lib/config.js";
+import { getEffectiveIgnores, DEFAULT_IGNORES } from "../src/lib/ignore.js";
 import type { RootConfig } from "../src/lib/types.js";
 
 vi.mock("node:fs/promises", () => ({
@@ -88,6 +89,146 @@ describe("config", () => {
       expect(project.rootName).toBe("my-code");
       expect((project as { group?: string }).group).toBeUndefined();
     });
+
+    it("returns ignores when set in config", async () => {
+      const configPath = getConfigPath();
+      const projectsPath = getProjectsPath();
+      vi.mocked(fs.readFile).mockImplementation((p: string) => {
+        if (p === configPath) {
+          return Promise.resolve(
+            JSON.stringify({
+              version: 1,
+              roots: [],
+              ignores: ["**/foo/**", "**/bar"],
+            }),
+          );
+        }
+        if (p === projectsPath) {
+          return Promise.resolve(JSON.stringify({ projects: {} }));
+        }
+        return Promise.reject(new Error("ENOENT"));
+      });
+
+      const config = await readConfig();
+
+      expect(config.ignores).toEqual(["**/foo/**", "**/bar"]);
+    });
+
+    it("leaves ignores undefined when not in config", async () => {
+      const configPath = getConfigPath();
+      const projectsPath = getProjectsPath();
+      vi.mocked(fs.readFile).mockImplementation((p: string) => {
+        if (p === configPath) {
+          return Promise.resolve(JSON.stringify({ version: 1, roots: [] }));
+        }
+        if (p === projectsPath) {
+          return Promise.resolve(JSON.stringify({ projects: {} }));
+        }
+        return Promise.reject(new Error("ENOENT"));
+      });
+
+      const config = await readConfig();
+
+      expect(config.ignores).toBeUndefined();
+    });
+
+    it("returns slugParentFolders when set in config", async () => {
+      const configPath = getConfigPath();
+      const projectsPath = getProjectsPath();
+      vi.mocked(fs.readFile).mockImplementation((p: string) => {
+        if (p === configPath) {
+          return Promise.resolve(
+            JSON.stringify({
+              version: 1,
+              roots: [],
+              slugParentFolders: ["src", "app", "packages"],
+            }),
+          );
+        }
+        if (p === projectsPath) {
+          return Promise.resolve(JSON.stringify({ projects: {} }));
+        }
+        return Promise.reject(new Error("ENOENT"));
+      });
+
+      const config = await readConfig();
+
+      expect(config.slugParentFolders).toEqual(["src", "app", "packages"]);
+    });
+
+    it("leaves slugParentFolders undefined when not in config", async () => {
+      const configPath = getConfigPath();
+      const projectsPath = getProjectsPath();
+      vi.mocked(fs.readFile).mockImplementation((p: string) => {
+        if (p === configPath) {
+          return Promise.resolve(JSON.stringify({ version: 1, roots: [] }));
+        }
+        if (p === projectsPath) {
+          return Promise.resolve(JSON.stringify({ projects: {} }));
+        }
+        return Promise.reject(new Error("ENOENT"));
+      });
+
+      const config = await readConfig();
+
+      expect(config.slugParentFolders).toBeUndefined();
+    });
+
+    it("reads and normalizes ignoredPaths from config", async () => {
+      const configPath = getConfigPath();
+      const projectsPath = getProjectsPath();
+      const resolvedPath = path.resolve("/code/some-project");
+      vi.mocked(fs.readFile).mockImplementation((p: string) => {
+        if (p === configPath) {
+          return Promise.resolve(
+            JSON.stringify({
+              version: 1,
+              roots: [],
+              ignoredPaths: ["/code/some-project", "~/other"],
+            }),
+          );
+        }
+        if (p === projectsPath) {
+          return Promise.resolve(JSON.stringify({ projects: {} }));
+        }
+        return Promise.reject(new Error("ENOENT"));
+      });
+
+      const config = await readConfig();
+
+      expect(config.ignoredPaths).toBeDefined();
+      expect(config.ignoredPaths).toHaveLength(2);
+      expect(config.ignoredPaths![0]).toBe(resolvedPath);
+      expect(config.ignoredPaths![1]).toBe(path.resolve(process.env.HOME || "", "other"));
+    });
+
+    it("leaves ignoredPaths undefined when not in config", async () => {
+      const configPath = getConfigPath();
+      const projectsPath = getProjectsPath();
+      vi.mocked(fs.readFile).mockImplementation((p: string) => {
+        if (p === configPath) {
+          return Promise.resolve(JSON.stringify({ version: 1, roots: [] }));
+        }
+        if (p === projectsPath) {
+          return Promise.resolve(JSON.stringify({ projects: {} }));
+        }
+        return Promise.reject(new Error("ENOENT"));
+      });
+
+      const config = await readConfig();
+
+      expect(config.ignoredPaths).toBeUndefined();
+    });
+  });
+
+  describe("getEffectiveIgnores", () => {
+    it("returns DEFAULT_IGNORES when config has no ignores", () => {
+      expect(getEffectiveIgnores({})).toEqual(DEFAULT_IGNORES);
+    });
+
+    it("returns only user ignores when config.ignores is set (no merge)", () => {
+      expect(getEffectiveIgnores({ ignores: ["x"] })).toEqual(["x"]);
+    });
   });
 
   describe("resolveRoots", () => {
@@ -103,4 +244,37 @@ describe("config", () => {
       expect(result[1]).toEqual({ path: path.resolve("/c"), name: "c" });
     });
   });
+
+  describe("writeConfig", () => {
+    it("writes ignoredPaths to app config when present", async () => {
+      const configPath = getConfigPath();
+      const projectsPath = getProjectsPath();
+      vi.mocked(fs.readFile).mockImplementation((p: string) => {
+        if (p === configPath) {
+          return Promise.resolve(JSON.stringify({ version: 1, roots: [] }));
+        }
+        if (p === projectsPath) {
+          return Promise.resolve(JSON.stringify({ projects: {} }));
+        }
+        return Promise.reject(new Error("ENOENT"));
+      });
+      const config = await readConfig();
+      const configWithIgnores = {
+        ...config,
+        ignoredPaths: [path.resolve("/code/foo"), path.resolve("/code/bar")],
+      };
+
+      await writeConfig(configWithIgnores);
+
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        configPath,
+        expect.stringContaining('"ignoredPaths"'),
+        "utf8",
+      );
+      const written = JSON.parse(
+        String(vi.mocked(fs.writeFile).mock.calls.find((c) => c[0] === configPath)![1]),
+      );
+      expect(written.ignoredPaths).toEqual([path.resolve("/code/foo"), path.resolve("/code/bar")]);
+    });
+  });
 });