bet-cli 0.2.0 → 0.3.1

package/src/lib/help.ts

@@ -1,7 +1,7 @@
 import { Help } from "commander";
 import type { Command } from "commander";
 
-const GROUP_1: string[] = ["list", "search", "info", "go", "path"];
+const GROUP_1: string[] = ["list", "search", "info", "go", "edit", "path"];
 const GROUP_2: string[] = ["shell", "completion"];
 const GROUP_3: string[] = ["update", "ignore", "help"];
 
@@ -55,23 +55,24 @@ export class GroupedHelp extends Help {
     }
 
     // Arguments
-    const argumentList = helper.visibleArguments(cmd).map((argument) =>
-      formatItem(
-        helper.argumentTerm(argument),
-        helper.argumentDescription(argument),
-      ),
-    );
+    const argumentList = helper
+      .visibleArguments(cmd)
+      .map((argument) =>
+        formatItem(
+          helper.argumentTerm(argument),
+          helper.argumentDescription(argument),
+        ),
+      );
     if (argumentList.length > 0) {
       output.push("Arguments:", formatList(argumentList), "");
     }
 
     // Options
-    const optionList = helper.visibleOptions(cmd).map((option) =>
-      formatItem(
-        helper.optionTerm(option),
-        helper.optionDescription(option),
-      ),
-    );
+    const optionList = helper
+      .visibleOptions(cmd)
+      .map((option) =>
+        formatItem(helper.optionTerm(option), helper.optionDescription(option)),
+      );
     if (optionList.length > 0) {
       output.push("Options:", formatList(optionList), "");
     }
@@ -105,8 +106,7 @@ export class GroupedHelp extends Help {
       const groupIndices = [...byGroup.keys()].sort((a, b) => a - b);
       for (const idx of groupIndices) {
         const commands = byGroup.get(idx)!;
-        const heading =
-          idx < GROUPS.length ? GROUPS[idx].heading : "Commands";
+        const heading = idx < GROUPS.length ? GROUPS[idx].heading : "Commands";
         const commandList = commands.map((sub) =>
           formatItem(
             helper.subcommandTerm(sub),
@@ -117,6 +117,19 @@ export class GroupedHelp extends Help {
       }
     }
 
+    output.push(
+      "AI agent skill:",
+      formatList([
+        "bet ships an agent skill that teaches AI coding agents (Claude Code,",
+        "Cursor, etc.) how to drive this CLI from natural-language requests.",
+        "Install it to supercharge your agent — drop the skills/bet/ folder",
+        "into your harness's skills directory (e.g. ~/.claude/skills/bet/).",
+        "",
+        "  https://github.com/kenzic/bet-cli/tree/main/skills/bet",
+      ]),
+      "",
+    );
+
     return output.join("\n");
   }
 }

package/src/lib/types.ts

@@ -33,6 +33,7 @@ export type RootConfig = {
 export type AppConfig = {
   version: number;
   roots: RootConfig[];
+  editor?: string;
   ignores?: string[];
   ignoredPaths?: string[];
   slugParentFolders?: string[];
@@ -46,6 +47,7 @@ export type ProjectsConfig = {
 export type Config = {
   version: number;
   roots: RootConfig[];
+  editor?: string;
   ignores?: string[];
   ignoredPaths?: string[];
   slugParentFolders?: string[];

package/src/main.ts

@@ -9,6 +9,7 @@ import { registerPath } from "./commands/path.js";
 import { registerShell } from "./commands/shell.js";
 import { registerCompletion } from "./commands/completion.js";
 import { registerIgnore } from "./commands/ignore.js";
+import { registerEdit } from "./commands/edit.js";
 
 const ASCII_HEADER = `
                             ░░░░░   ░░░░░░░░░░░░░░░░░░░░░░░░░░   ░░░░░░░░░░░░░░░░░░░░░░░░░░
@@ -38,13 +39,14 @@ program.createHelp = function createHelp(this: Command) {
 program
   .name("bet")
   .description("Explore and jump between local projects.")
-  .version("0.2.0");
+  .version("0.3.1");
 
 registerUpdate(program);
 registerList(program);
 registerSearch(program);
 registerInfo(program);
 registerGo(program);
+registerEdit(program);
 registerPath(program);
 registerShell(program);
 registerCompletion(program);

package/tests/config.test.ts

@@ -114,6 +114,54 @@ describe("config", () => {
       expect(config.ignores).toEqual(["**/foo/**", "**/bar"]);
     });
 
+    it("returns editor 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: [],
+              editor: "code -n",
+            }),
+          );
+        }
+        if (p === projectsPath) {
+          return Promise.resolve(JSON.stringify({ projects: {} }));
+        }
+        return Promise.reject(new Error("ENOENT"));
+      });
+
+      const config = await readConfig();
+
+      expect(config.editor).toBe("code -n");
+    });
+
+    it("normalizes blank editor to undefined", 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: [],
+              editor: "   ",
+            }),
+          );
+        }
+        if (p === projectsPath) {
+          return Promise.resolve(JSON.stringify({ projects: {} }));
+        }
+        return Promise.reject(new Error("ENOENT"));
+      });
+
+      const config = await readConfig();
+
+      expect(config.editor).toBeUndefined();
+    });
+
     it("leaves ignores undefined when not in config", async () => {
       const configPath = getConfigPath();
       const projectsPath = getProjectsPath();
@@ -276,5 +324,28 @@ describe("config", () => {
       );
       expect(written.ignoredPaths).toEqual([path.resolve("/code/foo"), path.resolve("/code/bar")]);
     });
+
+    it("writes editor 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();
+
+      await writeConfig({ ...config, editor: "cursor" });
+
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        configPath,
+        expect.stringContaining('"editor": "cursor"'),
+        "utf8",
+      );
+    });
   });
 });

package/tests/editor.test.ts

@@ -0,0 +1,167 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { EventEmitter } from "node:events";
+import { getSystemOpenCommand, openProjectInEditor, parseEditorCommand } from "../src/lib/editor.js";
+
+vi.mock("node:child_process", () => ({
+  spawn: vi.fn(),
+}));
+
+import { spawn } from "node:child_process";
+
+type SpawnedProcess = EventEmitter & {
+  unref: ReturnType<typeof vi.fn>;
+};
+
+function createSpawnedProcess(): SpawnedProcess {
+  const child = new EventEmitter() as SpawnedProcess;
+  child.unref = vi.fn();
+  return child;
+}
+
+describe("editor", () => {
+  beforeEach(() => {
+    vi.mocked(spawn).mockReset();
+  });
+
+  describe("parseEditorCommand", () => {
+    it("parses command and args", () => {
+      expect(parseEditorCommand("code -n")).toEqual({
+        command: "code",
+        args: ["-n"],
+      });
+    });
+
+    it("handles quoted args", () => {
+      expect(parseEditorCommand('cursor --profile "Work Profile"')).toEqual({
+        command: "cursor",
+        args: ["--profile", "Work Profile"],
+      });
+    });
+
+    it("throws for malformed command", () => {
+      expect(() => parseEditorCommand('code "unterminated')).toThrow(
+        "Invalid editor command in config.",
+      );
+    });
+  });
+
+  describe("getSystemOpenCommand", () => {
+    it("returns open on macOS", () => {
+      expect(getSystemOpenCommand("/tmp/project", "darwin")).toEqual({
+        command: "open",
+        args: ["/tmp/project"],
+      });
+    });
+
+    it("returns cmd start on windows", () => {
+      expect(getSystemOpenCommand("C:\\tmp\\project", "win32")).toEqual({
+        command: "cmd",
+        args: ["/c", "start", "", "C:\\tmp\\project"],
+      });
+    });
+
+    it("returns xdg-open on linux", () => {
+      expect(getSystemOpenCommand("/tmp/project", "linux")).toEqual({
+        command: "xdg-open",
+        args: ["/tmp/project"],
+      });
+    });
+  });
+
+  describe("openProjectInEditor", () => {
+    it("uses configured editor command with project path", async () => {
+      const child = createSpawnedProcess();
+      vi.mocked(spawn).mockReturnValue(child as never);
+
+      const openPromise = openProjectInEditor("/tmp/project", "code -n");
+      child.emit("spawn");
+      await openPromise;
+
+      expect(spawn).toHaveBeenCalledWith("code", ["-n", "/tmp/project"], {
+        detached: true,
+        stdio: "ignore",
+      });
+      expect(child.unref).toHaveBeenCalledTimes(1);
+    });
+
+    it("falls back to system opener when editor is not configured", async () => {
+      const child = createSpawnedProcess();
+      vi.mocked(spawn).mockReturnValue(child as never);
+
+      const openPromise = openProjectInEditor("/tmp/project", undefined, {});
+      child.emit("spawn");
+      await openPromise;
+
+      expect(spawn).toHaveBeenCalledTimes(1);
+      expect(child.unref).toHaveBeenCalledTimes(1);
+    });
+
+    it("uses VISUAL when config editor is not set", async () => {
+      const child = createSpawnedProcess();
+      vi.mocked(spawn).mockReturnValue(child as never);
+
+      const openPromise = openProjectInEditor(
+        "/tmp/project",
+        undefined,
+        { VISUAL: "nvim" },
+      );
+      child.emit("spawn");
+      await openPromise;
+
+      expect(spawn).toHaveBeenCalledWith("nvim", ["/tmp/project"], {
+        detached: true,
+        stdio: "ignore",
+      });
+      expect(child.unref).toHaveBeenCalledTimes(1);
+    });
+
+    it("uses EDITOR when VISUAL is not set", async () => {
+      const child = createSpawnedProcess();
+      vi.mocked(spawn).mockReturnValue(child as never);
+
+      const openPromise = openProjectInEditor(
+        "/tmp/project",
+        undefined,
+        { EDITOR: "vim -p" },
+      );
+      child.emit("spawn");
+      await openPromise;
+
+      expect(spawn).toHaveBeenCalledWith("vim", ["-p", "/tmp/project"], {
+        detached: true,
+        stdio: "ignore",
+      });
+      expect(child.unref).toHaveBeenCalledTimes(1);
+    });
+
+    it("prefers VISUAL over EDITOR", async () => {
+      const child = createSpawnedProcess();
+      vi.mocked(spawn).mockReturnValue(child as never);
+
+      const openPromise = openProjectInEditor(
+        "/tmp/project",
+        undefined,
+        { VISUAL: "nvim", EDITOR: "vim" },
+      );
+      child.emit("spawn");
+      await openPromise;
+
+      expect(spawn).toHaveBeenCalledWith("nvim", ["/tmp/project"], {
+        detached: true,
+        stdio: "ignore",
+      });
+      expect(child.unref).toHaveBeenCalledTimes(1);
+    });
+
+    it("throws when spawn fails", async () => {
+      const child = createSpawnedProcess();
+      vi.mocked(spawn).mockReturnValue(child as never);
+
+      const openPromise = openProjectInEditor("/tmp/project", "code");
+      const error = new Error("missing executable");
+      child.emit("error", error);
+
+      await expect(openPromise).rejects.toThrow("missing executable");
+    });
+  });
+});