bet-cli 0.1.2 → 0.1.3

package/tests/cron.test.ts

@@ -0,0 +1,243 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { spawnSync } from "node:child_process";
+import {
+  parseCronSchedule,
+  scheduleToCronExpression,
+  formatScheduleLabel,
+  installUpdateCron,
+  uninstallUpdateCron,
+} from "../src/lib/cron.js";
+import { getConfigPath } from "../src/lib/config.js";
+
+vi.mock("../src/lib/config.js", () => ({
+  getConfigPath: vi.fn(() => path.join("/tmp", "bet-cron-test", "config.json")),
+}));
+
+vi.mock("node:fs/promises", () => ({
+  default: {
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+    mkdir: vi.fn(),
+    chmod: vi.fn(),
+  },
+}));
+
+vi.mock("node:child_process", () => ({
+  spawnSync: vi.fn(),
+}));
+
+describe("cron", () => {
+  describe("parseCronSchedule", () => {
+    it("parses valid minute schedules (1-59)", () => {
+      expect(parseCronSchedule("1m")).toEqual({ value: 1, unit: "m" });
+      expect(parseCronSchedule("5m")).toEqual({ value: 5, unit: "m" });
+      expect(parseCronSchedule("30m")).toEqual({ value: 30, unit: "m" });
+      expect(parseCronSchedule("59m")).toEqual({ value: 59, unit: "m" });
+    });
+
+    it("parses valid hour schedules (1-24)", () => {
+      expect(parseCronSchedule("1h")).toEqual({ value: 1, unit: "h" });
+      expect(parseCronSchedule("12h")).toEqual({ value: 12, unit: "h" });
+      expect(parseCronSchedule("24h")).toEqual({ value: 24, unit: "h" });
+    });
+
+    it("parses valid day schedules (1-31)", () => {
+      expect(parseCronSchedule("1d")).toEqual({ value: 1, unit: "d" });
+      expect(parseCronSchedule("7d")).toEqual({ value: 7, unit: "d" });
+      expect(parseCronSchedule("31d")).toEqual({ value: 31, unit: "d" });
+    });
+
+    it("accepts case-insensitive unit", () => {
+      expect(parseCronSchedule("5M")).toEqual({ value: 5, unit: "m" });
+      expect(parseCronSchedule("2H")).toEqual({ value: 2, unit: "h" });
+      expect(parseCronSchedule("1D")).toEqual({ value: 1, unit: "d" });
+    });
+
+    it("trims and lowercases input", () => {
+      expect(parseCronSchedule("  5m  ")).toEqual({ value: 5, unit: "m" });
+    });
+
+    it("throws on invalid format", () => {
+      expect(() => parseCronSchedule("")).toThrow(/Invalid cron schedule/);
+      expect(() => parseCronSchedule("5")).toThrow(/Invalid cron schedule/);
+      expect(() => parseCronSchedule("m")).toThrow(/Invalid cron schedule/);
+      expect(() => parseCronSchedule("1x")).toThrow(/Invalid cron schedule/);
+      expect(() => parseCronSchedule("m5")).toThrow(/Invalid cron schedule/);
+      expect(() => parseCronSchedule("5min")).toThrow(/Invalid cron schedule/);
+    });
+
+    it("throws on invalid minute range (0, 60, 61)", () => {
+      expect(() => parseCronSchedule("0m")).toThrow(/Invalid minutes: 0/);
+      expect(() => parseCronSchedule("60m")).toThrow(/Invalid minutes: 60/);
+      expect(() => parseCronSchedule("61m")).toThrow(/Invalid minutes: 61/);
+    });
+
+    it("throws on invalid hour range (0, 25)", () => {
+      expect(() => parseCronSchedule("0h")).toThrow(/Invalid hours: 0/);
+      expect(() => parseCronSchedule("25h")).toThrow(/Invalid hours: 25/);
+    });
+
+    it("throws on invalid day range (0, 32)", () => {
+      expect(() => parseCronSchedule("0d")).toThrow(/Invalid days: 0/);
+      expect(() => parseCronSchedule("32d")).toThrow(/Invalid days: 32/);
+    });
+  });
+
+  describe("scheduleToCronExpression", () => {
+    it("maps minutes to */N * * * *", () => {
+      expect(scheduleToCronExpression({ value: 1, unit: "m" })).toBe("*/1 * * * *");
+      expect(scheduleToCronExpression({ value: 5, unit: "m" })).toBe("*/5 * * * *");
+      expect(scheduleToCronExpression({ value: 30, unit: "m" })).toBe("*/30 * * * *");
+    });
+
+    it("maps hours to 0 */N * * *", () => {
+      expect(scheduleToCronExpression({ value: 1, unit: "h" })).toBe("0 */1 * * *");
+      expect(scheduleToCronExpression({ value: 2, unit: "h" })).toBe("0 */2 * * *");
+      expect(scheduleToCronExpression({ value: 12, unit: "h" })).toBe("0 */12 * * *");
+    });
+
+    it("maps 24h to midnight daily", () => {
+      expect(scheduleToCronExpression({ value: 24, unit: "h" })).toBe("0 0 * * *");
+    });
+
+    it("maps days to 0 0 */N * *", () => {
+      expect(scheduleToCronExpression({ value: 1, unit: "d" })).toBe("0 0 */1 * *");
+      expect(scheduleToCronExpression({ value: 7, unit: "d" })).toBe("0 0 */7 * *");
+      expect(scheduleToCronExpression({ value: 31, unit: "d" })).toBe("0 0 */31 * *");
+    });
+  });
+
+  describe("formatScheduleLabel", () => {
+    it("formats minutes (singular and plural)", () => {
+      expect(formatScheduleLabel({ value: 1, unit: "m" })).toBe("every minute");
+      expect(formatScheduleLabel({ value: 5, unit: "m" })).toBe("every 5 minutes");
+    });
+
+    it("formats hours (singular and plural)", () => {
+      expect(formatScheduleLabel({ value: 1, unit: "h" })).toBe("every hour");
+      expect(formatScheduleLabel({ value: 2, unit: "h" })).toBe("every 2 hours");
+    });
+
+    it("formats days (singular and plural)", () => {
+      expect(formatScheduleLabel({ value: 1, unit: "d" })).toBe("every day");
+      expect(formatScheduleLabel({ value: 7, unit: "d" })).toBe("every 7 days");
+    });
+  });
+
+  describe("installUpdateCron (mocked)", () => {
+    const configDir = path.join("/tmp", "bet-cron-test");
+    const wrapperPath = path.join(configDir, "bet-update-cron.sh");
+
+    beforeEach(() => {
+      vi.mocked(getConfigPath).mockReturnValue(path.join(configDir, "config.json"));
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+      vi.mocked(fs.chmod).mockResolvedValue(undefined);
+    });
+
+    it("throws on invalid schedule", async () => {
+      await expect(
+        installUpdateCron({
+          nodePath: "/usr/bin/node",
+          entryScriptPath: "/usr/bin/bet",
+          schedule: "61m",
+        }),
+      ).rejects.toThrow(/Invalid minutes: 61/);
+    });
+
+    it("replaces existing bet cron block (single block)", async () => {
+      const existingCrontab = [
+        "# other job",
+        "0 9 * * * /run/backup",
+        "# bet:update",
+        "0 * * * * /old/wrapper.sh",
+        "",
+      ].join("\n");
+
+      let writtenCrontab = "";
+      vi.mocked(spawnSync).mockImplementation((cmd, args, opts) => {
+        if (cmd === "crontab" && args?.[0] === "-l") {
+          return { status: 0, stdout: existingCrontab, stderr: "", output: [] } as ReturnType<typeof spawnSync>;
+        }
+        if (cmd === "crontab" && args?.[0] === "-" && opts?.input) {
+          writtenCrontab = opts.input as string;
+          return { status: 0, stdout: "", stderr: "", output: [] } as ReturnType<typeof spawnSync>;
+        }
+        return { status: 1, stdout: "", stderr: "unexpected", output: [] } as ReturnType<typeof spawnSync>;
+      });
+
+      await installUpdateCron({
+        nodePath: "/usr/bin/node",
+        entryScriptPath: "/usr/bin/bet",
+        schedule: "5m",
+      });
+
+      expect(writtenCrontab).toContain("# other job");
+      expect(writtenCrontab).toContain("0 9 * * * /run/backup");
+      expect(writtenCrontab).toContain("# bet:update");
+      expect(writtenCrontab).toContain("*/5 * * * *");
+      expect(writtenCrontab).toContain(wrapperPath);
+      expect(writtenCrontab).not.toContain("/old/wrapper.sh");
+      const betBlocks = (writtenCrontab.match(/# bet:update/g) ?? []).length;
+      expect(betBlocks).toBe(1);
+    });
+  });
+
+  describe("uninstallUpdateCron (mocked)", () => {
+    beforeEach(() => {
+      vi.mocked(spawnSync).mockReset();
+    });
+
+    it("removes bet block and keeps rest of crontab", async () => {
+      const existingCrontab = [
+        "0 9 * * * /run/backup",
+        "# bet:update",
+        "0 * * * * /path/to/wrapper.sh",
+        "",
+      ].join("\n");
+      let writtenCrontab = "";
+
+      vi.mocked(spawnSync).mockImplementation((cmd, args, opts) => {
+        if (cmd === "crontab" && args?.[0] === "-l") {
+          return { status: 0, stdout: existingCrontab, stderr: "", output: [] } as ReturnType<typeof spawnSync>;
+        }
+        if (cmd === "crontab" && args?.[0] === "-" && opts?.input) {
+          writtenCrontab = opts.input as string;
+          return { status: 0, stdout: "", stderr: "", output: [] } as ReturnType<typeof spawnSync>;
+        }
+        return { status: 1, stdout: "", stderr: "unexpected", output: [] } as ReturnType<typeof spawnSync>;
+      });
+
+      await uninstallUpdateCron();
+
+      expect(writtenCrontab).toContain("0 9 * * * /run/backup");
+      expect(writtenCrontab).not.toContain("# bet:update");
+      expect(writtenCrontab).not.toContain("/path/to/wrapper.sh");
+    });
+
+    it("removes crontab when bet was the only entry", async () => {
+      const existingCrontab = ["# bet:update", "0 * * * * /path/to/wrapper.sh"].join("\n");
+      const calls: { cmd: string; args?: string[] }[] = [];
+
+      vi.mocked(spawnSync).mockImplementation((cmd, args) => {
+        calls.push({ cmd, args: args as string[] });
+        if (cmd === "crontab" && args?.[0] === "-l") {
+          return { status: 0, stdout: existingCrontab, stderr: "", output: [] } as ReturnType<typeof spawnSync>;
+        }
+        if (cmd === "crontab" && args?.[0] === "-r") {
+          return { status: 0, stdout: "", stderr: "", output: [] } as ReturnType<typeof spawnSync>;
+        }
+        if (cmd === "crontab" && args?.[0] === "-") {
+          return { status: 0, stdout: "", stderr: "", output: [] } as ReturnType<typeof spawnSync>;
+        }
+        return { status: 1, stdout: "", stderr: "unexpected", output: [] } as ReturnType<typeof spawnSync>;
+      });
+
+      await uninstallUpdateCron();
+
+      expect(calls.some((c) => c.cmd === "crontab" && c.args?.[0] === "-r")).toBe(true);
+    });
+  });
+});

package/tests/ignore.test.ts

@@ -0,0 +1,179 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import path from "node:path";
+import { isPathIgnored } from "../src/lib/ignore.js";
+import { Command } from "commander";
+import * as config from "../src/lib/config.js";
+
+vi.mock("../src/lib/config.js", () => ({
+  readConfig: vi.fn(),
+  writeConfig: vi.fn(),
+}));
+
+import { registerIgnore } from "../src/commands/ignore.js";
+
+describe("ignore lib", () => {
+  describe("isPathIgnored", () => {
+    it("returns true when project path equals an ignored path", () => {
+      const ignoredPaths = [path.resolve("/code/foo"), path.resolve("/code/bar")];
+      expect(isPathIgnored(path.resolve("/code/foo"), ignoredPaths)).toBe(true);
+      expect(isPathIgnored(path.resolve("/code/bar"), ignoredPaths)).toBe(true);
+    });
+
+    it("returns true when project path is under an ignored path", () => {
+      const ignoredPaths = [path.resolve("/code/foo")];
+      expect(isPathIgnored(path.resolve("/code/foo/nested"), ignoredPaths)).toBe(true);
+      expect(isPathIgnored(path.resolve("/code/foo/nested/deep"), ignoredPaths)).toBe(true);
+    });
+
+    it("returns false when project path is not in list and not under any entry", () => {
+      const ignoredPaths = [path.resolve("/code/foo")];
+      expect(isPathIgnored(path.resolve("/code/bar"), ignoredPaths)).toBe(false);
+      expect(isPathIgnored(path.resolve("/code"), ignoredPaths)).toBe(false);
+      expect(isPathIgnored(path.resolve("/other/foo"), ignoredPaths)).toBe(false);
+    });
+
+    it("returns false when ignoredPaths is empty", () => {
+      expect(isPathIgnored(path.resolve("/code/foo"), [])).toBe(false);
+    });
+  });
+});
+
+describe("ignore command", () => {
+  beforeEach(() => {
+    vi.mocked(config.readConfig).mockReset();
+    vi.mocked(config.writeConfig).mockReset();
+    process.exitCode = undefined;
+  });
+
+  async function runIgnore(args: string[]): Promise<string> {
+    const chunks: string[] = [];
+    const stdoutWrite = process.stdout.write.bind(process.stdout);
+    const stderrWrite = process.stderr.write.bind(process.stderr);
+    process.stdout.write = (chunk: string | Uint8Array) => {
+      chunks.push(typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk));
+      return true;
+    };
+    process.stderr.write = (chunk: string | Uint8Array) => {
+      chunks.push(typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk));
+      return true;
+    };
+    const program = new Command();
+    program.name("bet").version("0.1.0");
+    registerIgnore(program);
+    await program.parseAsync(["node", "bet", "ignore", ...args]);
+    process.stdout.write = stdoutWrite;
+    process.stderr.write = stderrWrite;
+    return chunks.join("");
+  }
+
+  it("ignore add fails when no roots configured", async () => {
+    vi.mocked(config.readConfig).mockResolvedValue({
+      version: 1,
+      roots: [],
+      projects: {},
+    } as Awaited<ReturnType<typeof config.readConfig>>);
+
+    await runIgnore(["add", "/code/foo"]);
+
+    expect(config.writeConfig).not.toHaveBeenCalled();
+    expect(process.exitCode).toBe(1);
+  });
+
+  it("ignore add fails when path is not under any root", async () => {
+    const codeRoot = path.resolve("/code");
+    vi.mocked(config.readConfig).mockResolvedValue({
+      version: 1,
+      roots: [{ path: codeRoot, name: "code" }],
+      projects: {},
+    } as Awaited<ReturnType<typeof config.readConfig>>);
+
+    await runIgnore(["add", "/other/foo"]);
+
+    expect(config.writeConfig).not.toHaveBeenCalled();
+    expect(process.exitCode).toBe(1);
+  });
+
+  it("ignore add persists path when under a root", async () => {
+    const codeRoot = path.resolve("/code");
+    vi.mocked(config.readConfig).mockResolvedValue({
+      version: 1,
+      roots: [{ path: codeRoot, name: "code" }],
+      projects: {},
+    } as Awaited<ReturnType<typeof config.readConfig>>);
+
+    await runIgnore(["add", path.join(codeRoot, "my-project")]);
+
+    expect(config.writeConfig).toHaveBeenCalledTimes(1);
+    const written = vi.mocked(config.writeConfig).mock.calls[0][0];
+    expect(written.ignoredPaths).toContain(path.resolve(codeRoot, "my-project"));
+  });
+
+  it("ignore add --this uses current folder", async () => {
+    const codeRoot = path.resolve("/code");
+    const cwd = path.join(codeRoot, "current-project");
+    const cwdSpy = vi.spyOn(process, "cwd").mockReturnValue(cwd);
+    vi.mocked(config.readConfig).mockResolvedValue({
+      version: 1,
+      roots: [{ path: codeRoot, name: "code" }],
+      projects: {},
+    } as Awaited<ReturnType<typeof config.readConfig>>);
+
+    await runIgnore(["add", "--this"]);
+
+    cwdSpy.mockRestore();
+    expect(config.writeConfig).toHaveBeenCalledTimes(1);
+    const written = vi.mocked(config.writeConfig).mock.calls[0][0];
+    expect(written.ignoredPaths).toContain(cwd);
+  });
+
+  it("ignore add errors when no path and no --this", async () => {
+    await runIgnore(["add"]);
+
+    expect(config.writeConfig).not.toHaveBeenCalled();
+    expect(process.exitCode).toBe(1);
+  });
+
+  it("ignore rm removes path from list", async () => {
+    const codeRoot = path.resolve("/code");
+    const ignoredPath = path.join(codeRoot, "foo");
+    vi.mocked(config.readConfig).mockResolvedValue({
+      version: 1,
+      roots: [{ path: codeRoot, name: "code" }],
+      projects: {},
+      ignoredPaths: [ignoredPath],
+    } as Awaited<ReturnType<typeof config.readConfig>>);
+
+    await runIgnore(["rm", ignoredPath]);
+
+    expect(config.writeConfig).toHaveBeenCalledTimes(1);
+    const written = vi.mocked(config.writeConfig).mock.calls[0][0];
+    expect(written.ignoredPaths).toBeUndefined();
+  });
+
+  it("ignore list prints each ignored path", async () => {
+    const codeRoot = path.resolve("/code");
+    vi.mocked(config.readConfig).mockResolvedValue({
+      version: 1,
+      roots: [],
+      projects: {},
+      ignoredPaths: [path.join(codeRoot, "a"), path.join(codeRoot, "b")],
+    } as Awaited<ReturnType<typeof config.readConfig>>);
+
+    const out = await runIgnore(["list"]);
+
+    expect(out).toContain(path.join(codeRoot, "a"));
+    expect(out).toContain(path.join(codeRoot, "b"));
+  });
+
+  it("ignore list prints nothing when no ignores", async () => {
+    vi.mocked(config.readConfig).mockResolvedValue({
+      version: 1,
+      roots: [],
+      projects: {},
+    } as Awaited<ReturnType<typeof config.readConfig>>);
+
+    const out = await runIgnore(["list"]);
+
+    expect(out).toBe("");
+  });
+});

package/tests/metadata.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { computeMetadata } from "../src/lib/metadata.js";
+import { DEFAULT_IGNORES } from "../src/lib/ignore.js";
 
 const mockFg = vi.fn();
 vi.mock("fast-glob", () => ({
@@ -31,7 +32,7 @@ describe("metadata", () => {
       { stats: { mtimeMs: now.getTime() - 10000 } },
       { stats: { mtimeMs: now.getTime() - 5000 } },
     ]);
-    const result = await computeMetadata("/some/project", false);
+    const result = await computeMetadata("/some/project", false, DEFAULT_IGNORES);
     expect(result.lastIndexedAt).toBeDefined();
     expect(result.startedAt).toBeDefined();
     expect(result.lastModifiedAt).toBeDefined();
@@ -47,7 +48,7 @@ describe("metadata", () => {
     const readme = await import("../src/lib/readme.js");
     vi.mocked(readme.readReadmeDescription).mockResolvedValue("A cool project");
 
-    const result = await computeMetadata("/repo", true);
+    const result = await computeMetadata("/repo", true, DEFAULT_IGNORES);
     expect(result.startedAt).toBe("2021-06-01T00:00:00Z");
     expect(result.dirty).toBe(true);
     expect(result.description).toBe("A cool project");

package/tests/scan.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import path from "node:path";
 import { scanRoots } from "../src/lib/scan.js";
+import { DEFAULT_IGNORES } from "../src/lib/ignore.js";
 
 const mockFg = vi.fn();
 vi.mock("fast-glob", () => ({
@@ -24,7 +25,7 @@ describe("scan", () => {
     mockFg
       .mockResolvedValueOnce(["proj/.git"])
       .mockResolvedValueOnce([]);
-    const result = await scanRoots([root]);
+    const result = await scanRoots([root], DEFAULT_IGNORES);
     expect(result.length).toBe(1);
     expect(result[0].path).toBe(path.join(root, "proj"));
     expect(result[0].hasGit).toBe(true);
@@ -35,7 +36,7 @@ describe("scan", () => {
     mockFg
       .mockResolvedValueOnce([])
       .mockResolvedValueOnce(["other/README.md"]);
-    const result = await scanRoots([root]);
+    const result = await scanRoots([root], DEFAULT_IGNORES);
     expect(result.length).toBe(1);
     expect(result[0].path).toBe(path.join(root, "other"));
     expect(result[0].hasReadme).toBe(true);
@@ -46,7 +47,7 @@ describe("scan", () => {
     mockFg
       .mockResolvedValueOnce(["parent/.git", "parent/child/.git"])
       .mockResolvedValueOnce([]);
-    const result = await scanRoots([root]);
+    const result = await scanRoots([root], DEFAULT_IGNORES);
     expect(result.length).toBe(1);
     expect(result[0].path).toBe(path.join(root, "parent"));
   });
@@ -60,7 +61,7 @@ describe("scan", () => {
     mockIsInsideGitRepo.mockImplementation((cwd: string) =>
       Promise.resolve(cwd === projectPath)
     );
-    const result = await scanRoots([root]);
+    const result = await scanRoots([root], DEFAULT_IGNORES);
     expect(result.length).toBe(1);
     expect(result[0].hasGit).toBe(true);
   });

package/tests/update.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { willOverrideRoots } from "../src/commands/update.js";
+import { willOverrideRoots, projectSlug, DEFAULT_SLUG_PARENT_FOLDERS } from "../src/commands/update.js";
 import type { RootConfig } from "../src/lib/types.js";
 
 const root = (path: string, name: string): RootConfig => ({ path, name });
@@ -27,4 +27,23 @@ describe("update", () => {
       expect(willOverrideRoots(undefined, [])).toBe(false);
     });
   });
+
+  describe("projectSlug", () => {
+    it("uses parent name when path ends with default slugParentFolders (src, app)", () => {
+      expect(projectSlug("/code/my-api/src", DEFAULT_SLUG_PARENT_FOLDERS)).toBe("my-api");
+      expect(projectSlug("/code/my-api/app", DEFAULT_SLUG_PARENT_FOLDERS)).toBe("my-api");
+    });
+
+    it("uses basename when path does not end with default slugParentFolders", () => {
+      expect(projectSlug("/code/my-api/other", DEFAULT_SLUG_PARENT_FOLDERS)).toBe("other");
+      expect(projectSlug("/code/my-api", DEFAULT_SLUG_PARENT_FOLDERS)).toBe("my-api");
+    });
+
+    it("uses custom slugParentFolders when provided", () => {
+      const custom = ["lib"];
+      expect(projectSlug("/code/my-api/lib", custom)).toBe("my-api");
+      expect(projectSlug("/code/my-api/src", custom)).toBe("src");
+      expect(projectSlug("/code/my-api/app", custom)).toBe("app");
+    });
+  });
 });