@vectorize-io/self-driving-agents 0.0.9 → 0.0.11

package/dist/cli.js

@@ -809,7 +809,96 @@ async function main() {
             apiToken = claudeConfig.apiToken;
         }
         else if (harness === "claude-code") {
-            // Claude Code: just save content locally, Claude handles the rest via skill
+            // Step 1: Ensure Claude Code CLI is available
+            try {
+                execSync("which claude", { stdio: "pipe" });
+            }
+            catch {
+                p.cancel("Claude Code CLI not found. Install it:\n  npm install -g @anthropic-ai/claude-code");
+                process.exit(1);
+            }
+            // Step 2: Ensure marketplace + plugin installed
+            const MARKETPLACE_REPO = "vectorize-io/hindsight";
+            const MARKETPLACE_NAME = "vectorize-io-hindsight";
+            const PLUGIN_NAME = "hindsight-memory";
+            let hasMarketplace = false;
+            try {
+                const out = execSync("claude plugin marketplace list", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+                hasMarketplace = out.includes(MARKETPLACE_NAME) || out.includes(MARKETPLACE_REPO);
+            }
+            catch { /* ignore */ }
+            if (!hasMarketplace) {
+                p.log.info("Adding Hindsight marketplace...");
+                try {
+                    execSync(`claude plugin marketplace add ${MARKETPLACE_REPO}`, { stdio: "inherit" });
+                    p.log.success("Marketplace added");
+                }
+                catch (err) {
+                    const msg = err?.stderr?.toString?.()?.trim() || err?.message || String(err);
+                    if (!msg.includes("already")) {
+                        p.log.warn(`Failed to add marketplace: ${msg}`);
+                    }
+                }
+            }
+            let pluginInstalled = false;
+            try {
+                const out = execSync("claude plugin list", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+                pluginInstalled = out.includes(PLUGIN_NAME);
+            }
+            catch { /* ignore */ }
+            if (!pluginInstalled) {
+                p.log.info("Installing hindsight-memory plugin...");
+                try {
+                    execSync(`claude plugin install ${PLUGIN_NAME}@${MARKETPLACE_NAME}`, { stdio: "inherit" });
+                    p.log.success("Plugin installed");
+                }
+                catch (err) {
+                    const msg = err?.stderr?.toString?.()?.trim() || err?.message || String(err);
+                    p.log.warn(`Failed to install plugin: ${msg}`);
+                }
+            }
+            else {
+                // Refresh marketplace catalog and update plugin to latest
+                p.log.info("Updating hindsight-memory plugin to latest version...");
+                try {
+                    execSync(`claude plugin marketplace update ${MARKETPLACE_NAME}`, { stdio: "pipe" });
+                }
+                catch { /* ignore — marketplace update is best-effort */ }
+                try {
+                    execSync(`claude plugin update ${PLUGIN_NAME}@${MARKETPLACE_NAME}`, { stdio: "inherit" });
+                    p.log.success("Plugin updated to latest");
+                }
+                catch (err) {
+                    const msg = err?.stderr?.toString?.()?.trim() || err?.message || String(err);
+                    p.log.warn(`Failed to update plugin: ${msg}`);
+                }
+            }
+            // Step 3: Configure Hindsight connection in ~/.hindsight/claude-code.json
+            const ccConfigDir = join(homedir(), ".hindsight");
+            const ccConfigPath = join(ccConfigDir, "claude-code.json");
+            let ccConfig = {};
+            if (existsSync(ccConfigPath)) {
+                try {
+                    ccConfig = JSON.parse(readFileSync(ccConfigPath, "utf-8"));
+                }
+                catch { /* ignore */ }
+            }
+            const hasConnection = ccConfig.hindsightApiUrl || ccConfig.llmProvider;
+            if (!hasConnection && process.stdin.isTTY) {
+                const claudeConfig = await promptClaudeConfig(agentId);
+                ccConfig.hindsightApiUrl = claudeConfig.apiUrl;
+                ccConfig.hindsightApiToken = claudeConfig.apiToken;
+                ccConfig.enableKnowledgeTools = true;
+                mkdirSync(ccConfigDir, { recursive: true });
+                writeFileSync(ccConfigPath, JSON.stringify(ccConfig, null, 2) + "\n");
+                p.log.success(`Hindsight connection saved to ${color.dim(ccConfigPath)}`);
+            }
+            else if (!ccConfig.enableKnowledgeTools) {
+                ccConfig.enableKnowledgeTools = true;
+                mkdirSync(ccConfigDir, { recursive: true });
+                writeFileSync(ccConfigPath, JSON.stringify(ccConfig, null, 2) + "\n");
+            }
+            // Step 4: Save content locally for the agent
             const contentDir = join(homedir(), ".self-driving-agents", "claude-code", agentId);
             mkdirSync(contentDir, { recursive: true });
             // Copy content files to the local dir

package/dist/tests/cli.test.js

@@ -527,3 +527,142 @@ describe("harness validation", () => {
         expect(SUPPORTED_HARNESSES.includes("")).toBe(false);
     });
 });
+// ── Claude Code plugin lifecycle decisions ──
+describe("claude-code plugin install/update logic", () => {
+    // Mirrors the decision logic in cli.ts:
+    //   - if plugin not in `claude plugin list` output → install
+    //   - else → run `claude plugin marketplace update` + `claude plugin update`
+    function shouldInstall(pluginListOutput, pluginName) {
+        return !pluginListOutput.includes(pluginName);
+    }
+    function shouldUpdate(pluginListOutput, pluginName) {
+        return pluginListOutput.includes(pluginName);
+    }
+    it("installs when plugin not present", () => {
+        const out = "Installed plugins:\n  ❯ rust-analyzer-lsp@claude-plugins-official\n    Version: 1.0.0";
+        expect(shouldInstall(out, "hindsight-memory")).toBe(true);
+        expect(shouldUpdate(out, "hindsight-memory")).toBe(false);
+    });
+    it("updates when plugin already present", () => {
+        const out = "Installed plugins:\n  ❯ hindsight-memory@vectorize-io-hindsight\n    Version: 0.5.0";
+        expect(shouldInstall(out, "hindsight-memory")).toBe(false);
+        expect(shouldUpdate(out, "hindsight-memory")).toBe(true);
+    });
+    it("detects plugin regardless of installed scope", () => {
+        const userScope = "  ❯ hindsight-memory@vectorize-io-hindsight\n    Scope: user";
+        const localScope = "  ❯ hindsight-memory@vectorize-io-hindsight\n    Scope: local";
+        expect(shouldUpdate(userScope, "hindsight-memory")).toBe(true);
+        expect(shouldUpdate(localScope, "hindsight-memory")).toBe(true);
+    });
+});
+describe("claude-code marketplace detection", () => {
+    // Mirrors the marketplace-add decision: if neither name nor repo is in the
+    // `claude plugin marketplace list` output, we run `claude plugin marketplace add`.
+    function hasMarketplace(out, name, repo) {
+        return out.includes(name) || out.includes(repo);
+    }
+    const MARKETPLACE_NAME = "vectorize-io-hindsight";
+    const MARKETPLACE_REPO = "vectorize-io/hindsight";
+    it("detects when marketplace already added by name", () => {
+        const out = "Configured marketplaces:\n  vectorize-io-hindsight (github: vectorize-io/hindsight)";
+        expect(hasMarketplace(out, MARKETPLACE_NAME, MARKETPLACE_REPO)).toBe(true);
+    });
+    it("detects when marketplace already added by repo", () => {
+        const out = "Configured marketplaces:\n  some-other-name (github: vectorize-io/hindsight)";
+        expect(hasMarketplace(out, MARKETPLACE_NAME, MARKETPLACE_REPO)).toBe(true);
+    });
+    it("returns false when marketplace not added", () => {
+        const out = "Configured marketplaces:\n  claude-plugins-official";
+        expect(hasMarketplace(out, MARKETPLACE_NAME, MARKETPLACE_REPO)).toBe(false);
+    });
+    it("returns false on empty marketplace list", () => {
+        expect(hasMarketplace("", MARKETPLACE_NAME, MARKETPLACE_REPO)).toBe(false);
+    });
+});
+describe("claude-code allowed-tools merge", () => {
+    // Mirrors the auto-approve logic that merges entries into ~/.claude/settings.json's allowedTools.
+    function mergeAllowed(existing, toAdd) {
+        const merged = [...existing];
+        let updated = false;
+        for (const tool of toAdd) {
+            if (!merged.includes(tool)) {
+                merged.push(tool);
+                updated = true;
+            }
+        }
+        return { merged, updated };
+    }
+    const HINDSIGHT_TOOLS = [
+        "mcp__hindsight__*",
+        "Skill(hindsight-memory:create-agent)",
+        "Bash(ls ~/.self-driving-agents/*)",
+        "Bash(cat ~/.self-driving-agents/*)",
+    ];
+    it("adds all tools to empty allowedTools", () => {
+        const { merged, updated } = mergeAllowed([], HINDSIGHT_TOOLS);
+        expect(updated).toBe(true);
+        expect(merged).toEqual(HINDSIGHT_TOOLS);
+    });
+    it("preserves existing entries", () => {
+        const { merged } = mergeAllowed(["Bash(npm *)", "Read"], HINDSIGHT_TOOLS);
+        expect(merged).toContain("Bash(npm *)");
+        expect(merged).toContain("Read");
+        expect(merged).toContain("mcp__hindsight__*");
+    });
+    it("does not duplicate when already present", () => {
+        const existing = [...HINDSIGHT_TOOLS];
+        const { merged, updated } = mergeAllowed(existing, HINDSIGHT_TOOLS);
+        expect(updated).toBe(false);
+        expect(merged).toHaveLength(HINDSIGHT_TOOLS.length);
+    });
+    it("only adds missing entries", () => {
+        const existing = ["mcp__hindsight__*"];
+        const { merged, updated } = mergeAllowed(existing, HINDSIGHT_TOOLS);
+        expect(updated).toBe(true);
+        expect(merged).toHaveLength(HINDSIGHT_TOOLS.length);
+    });
+});
+describe("claude-code Hindsight config persistence", () => {
+    // Mirrors the config-write logic: if existing config has a connection
+    // (hindsightApiUrl or llmProvider), don't prompt; otherwise prompt.
+    function shouldPromptConnection(config) {
+        return !config.hindsightApiUrl && !config.llmProvider;
+    }
+    function applyClaudeConfig(existing, prompted) {
+        return {
+            ...existing,
+            hindsightApiUrl: prompted.apiUrl,
+            hindsightApiToken: prompted.apiToken,
+            enableKnowledgeTools: true,
+        };
+    }
+    it("prompts on first install (empty config)", () => {
+        expect(shouldPromptConnection({})).toBe(true);
+    });
+    it("skips prompt when hindsightApiUrl already set", () => {
+        expect(shouldPromptConnection({ hindsightApiUrl: "https://api.example.com" })).toBe(false);
+    });
+    it("skips prompt when llmProvider already set (local daemon mode)", () => {
+        expect(shouldPromptConnection({ llmProvider: "openai" })).toBe(false);
+    });
+    it("writes Cloud connection on first install", () => {
+        const result = applyClaudeConfig({}, {
+            apiUrl: "https://api.hindsight.vectorize.io",
+            apiToken: "hsk_abc",
+        });
+        expect(result.hindsightApiUrl).toBe("https://api.hindsight.vectorize.io");
+        expect(result.hindsightApiToken).toBe("hsk_abc");
+        expect(result.enableKnowledgeTools).toBe(true);
+    });
+    it("preserves other settings when applying connection", () => {
+        const existing = { debug: true, retainEveryNTurns: 1 };
+        const result = applyClaudeConfig(existing, { apiUrl: "https://x.com", apiToken: "t" });
+        expect(result.debug).toBe(true);
+        expect(result.retainEveryNTurns).toBe(1);
+        expect(result.hindsightApiUrl).toBe("https://x.com");
+    });
+    it("always sets enableKnowledgeTools=true", () => {
+        const result = applyClaudeConfig({ enableKnowledgeTools: false }, { apiUrl: "https://x.com", apiToken: "t" });
+        expect(result.enableKnowledgeTools).toBe(true);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vectorize-io/self-driving-agents",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "Install self-driving agents with portable memory on any harness",
   "type": "module",
   "main": "dist/cli.js",