@vectorize-io/self-driving-agents 0.0.10 → 0.0.12

package/dist/cli.js

@@ -858,13 +858,20 @@ async function main() {
                 }
             }
             else {
-                // Update to latest
-                p.log.info("Updating hindsight-memory plugin...");
+                // Refresh marketplace catalog and update plugin to latest
+                p.log.info("Updating hindsight-memory plugin to latest version...");
                 try {
-                    execSync(`claude plugin update ${PLUGIN_NAME}@${MARKETPLACE_NAME}`, { stdio: "pipe" });
-                    p.log.success("Plugin up to date");
+                    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}`);
                 }
-                catch { /* ignore */ }
             }
             // Step 3: Configure Hindsight connection in ~/.hindsight/claude-code.json
             const ccConfigDir = join(homedir(), ".hindsight");
@@ -881,16 +888,35 @@ async function main() {
                 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");
+            // Verify/set bank granularity. SDA agents need per-project isolation —
+            // bank derived as agentName::projectBasename. If the user has a conflicting
+            // config (dynamicBankId: false with a static bankId), bail with instructions.
+            if (ccConfig.dynamicBankId === false && ccConfig.bankId) {
+                p.cancel(`Conflicting plugin config in ${ccConfigPath}:\n` +
+                    `  Found: dynamicBankId=false, bankId="${ccConfig.bankId}"\n` +
+                    `  Self-driving agents need dynamicBankId=true with granularity ["agent", "project"].\n` +
+                    `  Remove "dynamicBankId" and "bankId" from the config, or set them to:\n` +
+                    `    "dynamicBankId": true,\n` +
+                    `    "dynamicBankGranularity": ["agent", "project"]`);
+                process.exit(1);
+            }
+            const expectedGranularity = ["agent", "project"];
+            const currentGranularity = ccConfig.dynamicBankGranularity;
+            if (currentGranularity &&
+                JSON.stringify(currentGranularity) !== JSON.stringify(expectedGranularity)) {
+                p.cancel(`Conflicting plugin config in ${ccConfigPath}:\n` +
+                    `  Found: dynamicBankGranularity=${JSON.stringify(currentGranularity)}\n` +
+                    `  Self-driving agents require: ${JSON.stringify(expectedGranularity)}\n` +
+                    `  Update the config to match, or remove the field to let the installer set it.`);
+                process.exit(1);
             }
+            ccConfig.dynamicBankId = true;
+            ccConfig.dynamicBankGranularity = expectedGranularity;
+            ccConfig.enableKnowledgeTools = true;
+            mkdirSync(ccConfigDir, { recursive: true });
+            writeFileSync(ccConfigPath, JSON.stringify(ccConfig, null, 2) + "\n");
+            p.log.success(`Plugin config: ${color.dim(ccConfigPath)}`);
             // Step 4: Save content locally for the agent
             const contentDir = join(homedir(), ".self-driving-agents", "claude-code", agentId);
             mkdirSync(contentDir, { recursive: true });
@@ -937,13 +963,14 @@ async function main() {
                 writeFileSync(userSettingsPath, JSON.stringify(userSettings, null, 2) + "\n");
                 p.log.success("Auto-approved hindsight tools in Claude Code");
             }
-            const hasBankTemplate = existsSync(join(contentDir, "bank-template.json"));
-            const prompt = hasBankTemplate
-                ? `Use /hindsight-memory:create-agent to create a "${agentId}" agent. Then ingest all files from ${contentDir}/ (skip bank-template.json). Read ${contentDir}/bank-template.json and create the exact mental models (knowledge pages) defined in its "mental_models" array using agent_knowledge_create_page for each one.`
-                : `Use /hindsight-memory:create-agent to create a "${agentId}" agent. Then ingest all files from ${contentDir}/ and create 3 knowledge pages that make sense based on the content.`;
+            const prompt = `/hindsight-memory:create-agent ${agentId} from ${contentDir}`;
             p.note([
-                `${color.dim("1.")} Start Claude Code`,
-                `${color.dim("2.")} Say: ${color.cyan(prompt)}`,
+                `${color.yellow("⚠")}  ${color.bold(`Important:`)} the agent's memory is scoped to the directory where you start ${color.cyan("claude")}.`,
+                `   Always start your Claude Code sessions from the same project directory.`,
+                ``,
+                `${color.dim("1.")} ${color.cyan("cd")} into your project directory`,
+                `${color.dim("2.")} Run: ${color.cyan("claude")}`,
+                `${color.dim("3.")} Say: ${color.cyan(prompt)}`,
             ].join("\n"), "Next steps");
             p.outro(color.green(`'${agentId}' content ready`));
             cleanup?.();

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.10",
+  "version": "0.0.12",
   "description": "Install self-driving agents with portable memory on any harness",
   "type": "module",
   "main": "dist/cli.js",