bet-cli 0.1.0

package/tests/git.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const mockExecFile = vi.hoisted(() => vi.fn());
+
+vi.mock("node:child_process", () => ({
+  execFile: mockExecFile,
+}));
+
+vi.mock("node:util", () => ({
+  promisify: (fn: (...args: unknown[]) => Promise<{ stdout: string; stderr: string }>) => fn,
+}));
+
+describe("git", () => {
+  beforeEach(() => {
+    mockExecFile.mockReset();
+    vi.resetModules();
+  });
+
+  describe("getFirstCommitDate", () => {
+    it("returns first commit date when git succeeds", async () => {
+      mockExecFile.mockResolvedValueOnce({ stdout: "2020-01-15T10:00:00Z\n", stderr: "" });
+      const { getFirstCommitDate } = await import("../src/lib/git.js");
+      const result = await getFirstCommitDate("/some/repo");
+      expect(result).toBe("2020-01-15T10:00:00Z");
+    });
+
+    it("returns undefined when git fails", async () => {
+      mockExecFile.mockRejectedValueOnce(new Error("not a repo"));
+      const { getFirstCommitDate } = await import("../src/lib/git.js");
+      const result = await getFirstCommitDate("/not/repo");
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe("getDirtyStatus", () => {
+    it("returns true when porcelain output non-empty", async () => {
+      mockExecFile.mockResolvedValueOnce({ stdout: " M file\n", stderr: "" });
+      const { getDirtyStatus } = await import("../src/lib/git.js");
+      const result = await getDirtyStatus("/repo");
+      expect(result).toBe(true);
+    });
+
+    it("returns false when porcelain output empty", async () => {
+      mockExecFile.mockResolvedValueOnce({ stdout: "", stderr: "" });
+      const { getDirtyStatus } = await import("../src/lib/git.js");
+      const result = await getDirtyStatus("/repo");
+      expect(result).toBe(false);
+    });
+
+    it("returns undefined when git fails", async () => {
+      mockExecFile.mockRejectedValueOnce(new Error("not a repo"));
+      const { getDirtyStatus } = await import("../src/lib/git.js");
+      const result = await getDirtyStatus("/repo");
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe("isInsideGitRepo", () => {
+    it("returns true when rev-parse outputs true", async () => {
+      mockExecFile.mockResolvedValueOnce({ stdout: "true\n", stderr: "" });
+      const { isInsideGitRepo } = await import("../src/lib/git.js");
+      const result = await isInsideGitRepo("/repo");
+      expect(result).toBe(true);
+    });
+
+    it("returns false when rev-parse fails or outputs else", async () => {
+      mockExecFile.mockRejectedValueOnce(new Error("not a repo"));
+      const { isInsideGitRepo } = await import("../src/lib/git.js");
+      const result = await isInsideGitRepo("/repo");
+      expect(result).toBe(false);
+    });
+  });
+});

package/tests/metadata.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { computeMetadata } from "../src/lib/metadata.js";
+
+const mockFg = vi.fn();
+vi.mock("fast-glob", () => ({
+  default: (...args: unknown[]) => mockFg(...args),
+}));
+
+vi.mock("../src/lib/readme.js", () => ({
+  readReadmeDescription: vi.fn(),
+}));
+
+vi.mock("../src/lib/git.js", () => ({
+  getFirstCommitDate: vi.fn(),
+  getDirtyStatus: vi.fn(),
+}));
+
+describe("metadata", () => {
+  beforeEach(async () => {
+    mockFg.mockReset();
+    const readme = await import("../src/lib/readme.js");
+    const git = await import("../src/lib/git.js");
+    vi.mocked(readme.readReadmeDescription).mockResolvedValue(undefined);
+    vi.mocked(git.getFirstCommitDate).mockResolvedValue(undefined);
+    vi.mocked(git.getDirtyStatus).mockResolvedValue(undefined);
+  });
+
+  it("returns lastIndexedAt and uses file mtimes for started/lastModified when no git", async () => {
+    const now = new Date();
+    mockFg.mockResolvedValueOnce([
+      { stats: { mtimeMs: now.getTime() - 10000 } },
+      { stats: { mtimeMs: now.getTime() - 5000 } },
+    ]);
+    const result = await computeMetadata("/some/project", false);
+    expect(result.lastIndexedAt).toBeDefined();
+    expect(result.startedAt).toBeDefined();
+    expect(result.lastModifiedAt).toBeDefined();
+    expect(result.description).toBeUndefined();
+    expect(result.dirty).toBeUndefined();
+  });
+
+  it("uses getFirstCommitDate and getDirtyStatus when hasGit", async () => {
+    mockFg.mockResolvedValueOnce([]);
+    const git = await import("../src/lib/git.js");
+    vi.mocked(git.getFirstCommitDate).mockResolvedValue("2021-06-01T00:00:00Z");
+    vi.mocked(git.getDirtyStatus).mockResolvedValue(true);
+    const readme = await import("../src/lib/readme.js");
+    vi.mocked(readme.readReadmeDescription).mockResolvedValue("A cool project");
+
+    const result = await computeMetadata("/repo", true);
+    expect(result.startedAt).toBe("2021-06-01T00:00:00Z");
+    expect(result.dirty).toBe(true);
+    expect(result.description).toBe("A cool project");
+  });
+});

package/tests/output.test.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { emitSelection } from "../src/utils/output.js";
+import type { Project } from "../src/lib/types.js";
+
+const makeProject = (overrides: Partial<Project>): Project => ({
+  id: "/root/a",
+  slug: "a",
+  name: "a",
+  path: "/path/to/project",
+  root: "/root",
+  group: "root",
+  hasGit: true,
+  hasReadme: true,
+  auto: { lastIndexedAt: new Date().toISOString() },
+  ...overrides,
+});
+
+describe("output", () => {
+  let writeSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    writeSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true);
+  });
+
+  afterEach(() => {
+    writeSpy.mockRestore();
+  });
+
+  it("writes path only when printOnly is true", () => {
+    const project = makeProject({ path: "/my/project" });
+    emitSelection(project, { printOnly: true });
+    expect(writeSpy).toHaveBeenCalledWith("/my/project\n");
+  });
+
+  it("writes path only when BET_EVAL is not 1", () => {
+    const orig = process.env.BET_EVAL;
+    process.env.BET_EVAL = "0";
+    const project = makeProject({ path: "/my/project" });
+    emitSelection(project, {});
+    expect(writeSpy).toHaveBeenCalledWith("/my/project\n");
+    process.env.BET_EVAL = orig;
+  });
+
+  it("writes __BET_EVAL__ cd snippet when BET_EVAL=1 and no onEnter", () => {
+    const orig = process.env.BET_EVAL;
+    process.env.BET_EVAL = "1";
+    const project = makeProject({ path: "/my/project" });
+    emitSelection(project, {});
+    const out = writeSpy.mock.calls.map((c) => c[0]).join("");
+    expect(out).toContain("__BET_EVAL__");
+    expect(out).toContain('cd "/my/project"');
+    process.env.BET_EVAL = orig;
+  });
+
+  it("includes onEnter in snippet when BET_EVAL=1 and onEnter set", () => {
+    const orig = process.env.BET_EVAL;
+    process.env.BET_EVAL = "1";
+    const project = makeProject({
+      path: "/my/project",
+      user: { onEnter: "npm run dev" },
+    });
+    emitSelection(project, {});
+    const out = writeSpy.mock.calls.map((c) => c[0]).join("");
+    expect(out).toContain("__BET_EVAL__");
+    expect(out).toContain("npm run dev");
+    process.env.BET_EVAL = orig;
+  });
+
+  it("omits onEnter when noEnter is true", () => {
+    const orig = process.env.BET_EVAL;
+    process.env.BET_EVAL = "1";
+    const project = makeProject({
+      path: "/my/project",
+      user: { onEnter: "npm run dev" },
+    });
+    emitSelection(project, { noEnter: true });
+    const out = writeSpy.mock.calls.map((c) => c[0]).join("");
+    expect(out).not.toContain("npm run dev");
+    process.env.BET_EVAL = orig;
+  });
+});

package/tests/paths.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect } from "vitest";
+import path from "node:path";
+import { expandHome, normalizeAbsolute, isSubpath } from "../src/utils/paths.js";
+
+describe("paths", () => {
+  describe("expandHome", () => {
+    it("returns empty string unchanged", () => {
+      expect(expandHome("")).toBe("");
+    });
+
+    it("expands ~ to absolute homedir", () => {
+      const result = expandHome("~");
+      expect(path.isAbsolute(result)).toBe(true);
+      expect(result.length).toBeGreaterThan(0);
+    });
+
+    it("expands ~/path to homedir + path", () => {
+      const home = expandHome("~");
+      expect(expandHome("~/code")).toBe(path.join(home, "code"));
+    });
+
+    it("returns other paths unchanged", () => {
+      expect(expandHome("/abs/path")).toBe("/abs/path");
+      expect(expandHome("relative")).toBe("relative");
+    });
+  });
+
+  describe("normalizeAbsolute", () => {
+    it("resolves path with expanded home", () => {
+      const result = normalizeAbsolute("~/x");
+      expect(path.isAbsolute(result)).toBe(true);
+      expect(result).toBe(path.resolve(expandHome("~"), "x"));
+    });
+
+    it("resolves relative path", () => {
+      const result = normalizeAbsolute(".");
+      expect(path.isAbsolute(result)).toBe(true);
+    });
+  });
+
+  describe("isSubpath", () => {
+    it("returns true when child is under parent", () => {
+      expect(isSubpath("/a/b/c", "/a")).toBe(true);
+      expect(isSubpath("/a/b", "/a")).toBe(true);
+    });
+
+    it("returns false when paths are the same", () => {
+      expect(isSubpath("/a", "/a")).toBe(false);
+    });
+
+    it("returns false when child is not under parent", () => {
+      expect(isSubpath("/a", "/a/b")).toBe(false);
+      expect(isSubpath("/x/y", "/a")).toBe(false);
+    });
+
+    it("returns false when child goes up from parent", () => {
+      expect(isSubpath("/a/../b", "/a")).toBe(false);
+    });
+  });
+});

package/tests/projects.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect } from "vitest";
+import path from "node:path";
+import {
+  listProjects,
+  findBySlug,
+  projectLabel,
+} from "../src/lib/projects.js";
+import type { Config, Project } from "../src/lib/types.js";
+
+const makeProject = (overrides: Partial<Project>): Project => ({
+  id: "/root/a",
+  slug: "a",
+  name: "a",
+  path: "/root/a",
+  root: "/root",
+  rootName: "root",
+  hasGit: true,
+  hasReadme: true,
+  auto: { lastIndexedAt: new Date().toISOString() },
+  ...overrides,
+});
+
+describe("projects", () => {
+  describe("listProjects", () => {
+    it("returns projects sorted by rootName then slug", () => {
+      const config: Config = {
+        version: 1,
+        roots: [],
+        projects: {
+          "/root/c": makeProject({ path: "/root/c", slug: "c", rootName: "root" }),
+          "/root/a": makeProject({ path: "/root/a", slug: "a", rootName: "root" }),
+          "/other/x": makeProject({ path: "/other/x", slug: "x", rootName: "other" }),
+        },
+      };
+      const list = listProjects(config);
+      expect(list.map((p) => p.slug)).toEqual(["x", "a", "c"]);
+      expect(list.map((p) => p.rootName)).toEqual(["other", "root", "root"]);
+    });
+  });
+
+  describe("findBySlug", () => {
+    it("returns exact slug match (case-insensitive)", () => {
+      const projects: Project[] = [
+        makeProject({ slug: "MyProject", path: "/p1" }),
+        makeProject({ slug: "other", path: "/p2" }),
+      ];
+      expect(findBySlug(projects, "myproject").map((p) => p.path)).toEqual(["/p1"]);
+    });
+
+    it("trims slug", () => {
+      const projects: Project[] = [makeProject({ slug: "a", path: "/a" })];
+      expect(findBySlug(projects, "  a  ").length).toBe(1);
+    });
+
+    it("returns empty when no match", () => {
+      const projects: Project[] = [makeProject({ slug: "x", path: "/x" })];
+      expect(findBySlug(projects, "y")).toEqual([]);
+    });
+  });
+
+  describe("projectLabel", () => {
+    it("returns rootName/slug", () => {
+      const p = makeProject({ rootName: "g", slug: "s" });
+      expect(projectLabel(p)).toBe("g/s");
+    });
+  });
+});

package/tests/readme.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect, vi } from "vitest";
+import { readReadmeDescription } from "../src/lib/readme.js";
+
+vi.mock("node:fs/promises", () => ({
+  default: {
+    access: vi.fn(),
+    readFile: vi.fn(),
+  },
+}));
+
+describe("readme", () => {
+  describe("readReadmeDescription", () => {
+    it("returns title when only heading present", async () => {
+      const fs = await import("node:fs/promises");
+      vi.mocked(fs.default.access).mockResolvedValueOnce(undefined);
+      vi.mocked(fs.default.readFile).mockResolvedValueOnce("# My Project\n");
+
+      const result = await readReadmeDescription("/some/project");
+      expect(result).toBe("My Project");
+    });
+
+    it("returns first paragraph after title", async () => {
+      const fs = await import("node:fs/promises");
+      vi.mocked(fs.default.access).mockResolvedValueOnce(undefined);
+      vi.mocked(fs.default.readFile).mockResolvedValueOnce(
+        "# Title\n\nFirst paragraph here.\n\nSecond.\n"
+      );
+
+      const result = await readReadmeDescription("/some/project");
+      expect(result).toBe("First paragraph here.");
+    });
+
+    it("skips content inside code fences", async () => {
+      const fs = await import("node:fs/promises");
+      vi.mocked(fs.default.access).mockResolvedValueOnce(undefined);
+      vi.mocked(fs.default.readFile).mockResolvedValueOnce(
+        "# Title\n\nReal paragraph.\n\n```\ncode block\n```\n\nAfter.\n"
+      );
+
+      const result = await readReadmeDescription("/some/project");
+      expect(result).toBe("Real paragraph.");
+    });
+
+    it("returns undefined when no readme", async () => {
+      const fs = await import("node:fs/promises");
+      vi.mocked(fs.default.access).mockRejectedValue(new Error("not found"));
+
+      const result = await readReadmeDescription("/no/readme");
+      expect(result).toBeUndefined();
+    });
+  });
+});

package/tests/scan.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import path from "node:path";
+import { scanRoots } from "../src/lib/scan.js";
+
+const mockFg = vi.fn();
+vi.mock("fast-glob", () => ({
+  default: (...args: unknown[]) => mockFg(...args),
+}));
+
+const mockIsInsideGitRepo = vi.fn();
+vi.mock("../src/lib/git.js", () => ({
+  isInsideGitRepo: (cwd: string) => mockIsInsideGitRepo(cwd),
+}));
+
+describe("scan", () => {
+  beforeEach(() => {
+    mockFg.mockReset();
+    mockIsInsideGitRepo.mockReset();
+    mockIsInsideGitRepo.mockResolvedValue(false);
+  });
+
+  it("returns candidates from .git matches", async () => {
+    const root = path.resolve("/tmp/scan-root");
+    mockFg
+      .mockResolvedValueOnce(["proj/.git"])
+      .mockResolvedValueOnce([]);
+    const result = await scanRoots([root]);
+    expect(result.length).toBe(1);
+    expect(result[0].path).toBe(path.join(root, "proj"));
+    expect(result[0].hasGit).toBe(true);
+  });
+
+  it("returns candidates from README matches", async () => {
+    const root = path.resolve("/tmp/scan-root");
+    mockFg
+      .mockResolvedValueOnce([])
+      .mockResolvedValueOnce(["other/README.md"]);
+    const result = await scanRoots([root]);
+    expect(result.length).toBe(1);
+    expect(result[0].path).toBe(path.join(root, "other"));
+    expect(result[0].hasReadme).toBe(true);
+  });
+
+  it("filters nested projects", async () => {
+    const root = path.resolve("/tmp/scan-root");
+    mockFg
+      .mockResolvedValueOnce(["parent/.git", "parent/child/.git"])
+      .mockResolvedValueOnce([]);
+    const result = await scanRoots([root]);
+    expect(result.length).toBe(1);
+    expect(result[0].path).toBe(path.join(root, "parent"));
+  });
+
+  it("sets hasGit true when isInsideGitRepo returns true for candidate without .git", async () => {
+    const root = path.resolve("/tmp/scan-root");
+    mockFg
+      .mockResolvedValueOnce([])
+      .mockResolvedValueOnce(["nested/README.md"]);
+    const projectPath = path.join(root, "nested");
+    mockIsInsideGitRepo.mockImplementation((cwd: string) =>
+      Promise.resolve(cwd === projectPath)
+    );
+    const result = await scanRoots([root]);
+    expect(result.length).toBe(1);
+    expect(result[0].hasGit).toBe(true);
+  });
+});

package/tests/search.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from "vitest";
+import { searchProjects } from "../src/lib/search.js";
+import type { Project } from "../src/lib/types.js";
+
+const makeProject = (overrides: Partial<Project>): Project => ({
+  id: "/root/a",
+  slug: "a",
+  name: "a",
+  path: "/root/a",
+  root: "/root",
+  group: "root",
+  hasGit: true,
+  hasReadme: true,
+  auto: { lastIndexedAt: new Date().toISOString() },
+  ...overrides,
+});
+
+describe("search", () => {
+  const projects: Project[] = [
+    makeProject({ slug: "api-server", name: "API Server", path: "/code/api-server" }),
+    makeProject({ slug: "web-app", name: "Web App", path: "/code/web-app" }),
+    makeProject({ slug: "payments", name: "Payments", path: "/code/payments" }),
+  ];
+
+  it("returns all projects when query is blank", () => {
+    expect(searchProjects(projects, "")).toEqual(projects);
+    expect(searchProjects(projects, "   ")).toEqual(projects);
+  });
+
+  it("returns fuzzy matches for slug", () => {
+    const results = searchProjects(projects, "api");
+    expect(results.length).toBeGreaterThanOrEqual(1);
+    expect(results.some((p) => p.slug === "api-server")).toBe(true);
+  });
+
+  it("returns matches for partial name", () => {
+    const results = searchProjects(projects, "payment");
+    expect(results.some((p) => p.slug === "payments")).toBe(true);
+  });
+
+  it("returns empty when no match", () => {
+    const results = searchProjects(projects, "xyznonexistent");
+    expect(results).toEqual([]);
+  });
+});

package/tests/update.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from "vitest";
+import { willOverrideRoots } from "../src/commands/update.js";
+import type { RootConfig } from "../src/lib/types.js";
+
+const root = (path: string, name: string): RootConfig => ({ path, name });
+
+describe("update", () => {
+  describe("willOverrideRoots", () => {
+    it("returns true when --roots provided and config has roots", () => {
+      expect(
+        willOverrideRoots(
+          [root("/a", "a")],
+          [root("/b", "b")],
+        ),
+      ).toBe(true);
+    });
+
+    it("returns false when --roots not provided", () => {
+      expect(willOverrideRoots(undefined, [root("/b", "b")])).toBe(false);
+    });
+
+    it("returns false when config has no roots", () => {
+      expect(willOverrideRoots([root("/a", "a")], [])).toBe(false);
+    });
+
+    it("returns false when neither provided nor config roots", () => {
+      expect(willOverrideRoots(undefined, [])).toBe(false);
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "rootDir": "src",
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "jsx": "react-jsx"
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "tests", "**/*.test.ts", "**/*.spec.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,26 @@
+import { defineConfig } from "vitest/config";
+import { resolve } from "node:path";
+
+export default defineConfig({
+  test: {
+    environment: "node",
+    include: ["tests/**/*.test.ts"],
+  },
+  resolve: {
+    alias: {
+      "@": resolve(__dirname, "src"),
+    },
+  },
+  coverage: {
+    provider: "v8",
+    reporter: ["text", "html", "lcov"],
+    exclude: [
+      "dist/**",
+      "node_modules/**",
+      "src/index.ts",
+      "src/ui/**",
+      "**/*.test.ts",
+      "**/*.config.ts",
+    ],
+  },
+});