@lore-co/cli 0.2.22 → 0.2.23

package/dist/cli.js

@@ -12,11 +12,12 @@ import { withDirectoryLock } from "./reliability-store.js";
 import { runConfigCommand } from "./config-command.js";
 import { codexApprovalDetail, inspectCodexHookApproval } from "./codex-hook-approval.js";
 import { claudeOnlyCommand, disableDevinCli, runDevinCliHook } from "./devin-cli.js";
+import { LORE_MCP_SERVER_NAME, MCP_HOST_AGENTS, inspectCodexMcp, isLoreMcpServer, loreMcpServerEntry, mergeLoreCodexMcp, mergeLoreMcpServers, removeLoreCodexMcp, removeLoreMcpServers, } from "./mcp-config.js";
 import { access, chmod, copyFile, mkdir, open, readFile, readdir, rename, rm, stat, writeFile, } from "node:fs/promises";
 import { constants as fsConstants, realpathSync } from "node:fs";
 import { spawn, isWindows, windowsCommand, commandText, findExecutable, openBrowser } from "./platform.js";
 import { createHash, randomUUID } from "node:crypto";
-import { dirname, resolve } from "node:path";
+import { basename, dirname, resolve } from "node:path";
 import { homedir, hostname, platform } from "node:os";
 import { setTimeout as delay } from "node:timers/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -25,6 +26,7 @@ import { runHook, } from "./runtime.js";
 import { readInvocationHealthWriteInput, runInvocationHealthWrite, } from "./invocation-health-writer.js";
 import { runAskCommand } from "./ask.js";
 import { runLearningsCommand } from "./learnings.js";
+import { runReviewCommand } from "./review.js";
 import { runEmbeddingsCommand } from "./embeddings.js";
 import { runRememberCommand } from "./remember.js";
 import { installLoreSkill, removeLoreSkill } from "./skills.js";
@@ -398,6 +400,34 @@ export function removeLoreCursorMcp(input) {
     const { [CURSOR_MCP_NAME]: _lore, ...rest } = config.mcpServers;
     return { ...config, mcpServers: rest };
 }
+function isMcpHostAgent(agent) {
+    return MCP_HOST_AGENTS.includes(agent);
+}
+/** The full Lore MCP server, run by this CLI so it shares the hooks' credentials and version. */
+export function loreMcpServer(paths) {
+    return loreMcpServerEntry([process.execPath, ...(IS_STANDALONE_BINARY ? [] : [fileURLToPath(import.meta.url)])], paths.home);
+}
+/** Where each agent lists MCP servers, located from the hooks file Lore already manages. */
+export function mcpConfigPath(agent, hooksPath) {
+    const directory = dirname(hooksPath);
+    switch (agent) {
+        case "claude":
+            // ~/.claude/settings.json pairs with ~/.claude.json; a CLAUDE_CONFIG_DIR keeps both inside it.
+            return basename(directory) === ".claude"
+                ? resolve(directory, "..", ".claude.json")
+                : resolve(directory, ".claude.json");
+        case "codex":
+            return resolve(directory, "config.toml");
+        case "cursor":
+            return resolve(directory, "mcp.json");
+    }
+}
+export function mergeLoreMcp(input, agent, paths) {
+    return mergeLoreMcpServers(objectConfiguration(input, agent), loreMcpServer(paths), agent);
+}
+export function removeLoreMcp(input, agent) {
+    return removeLoreMcpServers(objectConfiguration(input, agent));
+}
 function stripLoreFromCursorEvent(value) {
     return Array.isArray(value) ? value.filter((hook) => !isLoreHook(hook)) : [];
 }
@@ -920,6 +950,39 @@ async function writeMergedJson(path, document, value, now) {
         ...(backup === undefined ? {} : { backup }),
     };
 }
+async function readTextDocument(path) {
+    try {
+        const [value, metadata] = await Promise.all([
+            readFile(path, "utf8"),
+            stat(path),
+        ]);
+        return { exists: true, value, mode: metadata.mode & 0o777 };
+    }
+    catch (error) {
+        const code = typeof error === "object" && error !== null && "code" in error
+            ? error.code
+            : undefined;
+        if (code === "ENOENT") {
+            return { exists: false, value: "", mode: 0o600 };
+        }
+        throw error;
+    }
+}
+async function writeMergedText(path, document, value, now) {
+    if (document.exists && document.value === value) {
+        return { changed: false };
+    }
+    let backup;
+    if (document.exists) {
+        backup = `${path}.lore-backup-${backupTimestamp(now)}-${randomUUID().slice(0, 8)}`;
+        await copyFile(path, backup, fsConstants.COPYFILE_EXCL);
+    }
+    await atomicWrite(path, value, document.mode);
+    return {
+        changed: true,
+        ...(backup === undefined ? {} : { backup }),
+    };
+}
 function parseConnectorConfig(value) {
     if (!isObject(value) ||
         (value.version !== 1 && value.version !== 2) ||
@@ -1145,7 +1208,8 @@ function objectConfiguration(input, agent) {
 const AGENT_TARGETS = {
     claude: {
         integration: "hooks",
-        expected: HOOK_EVENTS.length,
+        // Native hooks plus the Lore MCP server entry.
+        expected: HOOK_EVENTS.length + 1,
         runtimeRequired: true,
         emptyValue: () => ({}),
         configPath: (paths) => paths.claudeSettings,
@@ -1157,7 +1221,7 @@ const AGENT_TARGETS = {
     },
     codex: {
         integration: "hooks",
-        expected: HOOK_EVENTS.length,
+        expected: HOOK_EVENTS.length + 1,
         runtimeRequired: true,
         emptyValue: () => ({}),
         configPath: (paths) => paths.codexHooks,
@@ -1193,7 +1257,8 @@ const AGENT_TARGETS = {
     },
     cursor: {
         integration: "hooks",
-        expected: CURSOR_HOOK_EVENTS.length + 1,
+        // Hooks, the capture bridge, and the Lore MCP server entry.
+        expected: CURSOR_HOOK_EVENTS.length + 2,
         runtimeRequired: true,
         emptyValue: () => ({}),
         configPath: (paths) => paths.cursorHooks,
@@ -1548,6 +1613,99 @@ function mergeAgentConfig(input, agent, paths) {
 function removeAgentConfig(input, agent) {
     return targetFor(agent).remove(input);
 }
+/**
+ * Read each installation's hooks file and, for MCP hosts, its MCP config, and
+ * merge the Lore entries this CLI version writes. Nothing touches disk yet.
+ */
+async function prepareAgentEntries(installations, paths) {
+    const documents = new Map();
+    const mergedDocuments = new Map();
+    const mcpDocuments = new Map();
+    for (const installation of installations) {
+        const key = installationKey(installation);
+        const document = await readJsonDocument(installation.configPath);
+        documents.set(key, document);
+        mergedDocuments.set(key, mergeAgentConfig(document.value, installation.agent, paths));
+        if (isMcpHostAgent(installation.agent)) {
+            const mcpPath = mcpConfigPath(installation.agent, installation.configPath);
+            if (installation.agent === "codex") {
+                const text = await readTextDocument(mcpPath);
+                mcpDocuments.set(mcpPath, { kind: "text", document: text, merged: mergeLoreCodexMcp(text.value, loreMcpServer(paths)) });
+            }
+            else {
+                const mcp = await readJsonDocument(mcpPath);
+                const base = mcp.exists ? mcp.value : {};
+                // Cursor keeps its capture bridge next to the shared tool server.
+                const withBridge = installation.agent === "cursor" ? mergeLoreCursorMcp(base, paths) : base;
+                mcpDocuments.set(mcpPath, { kind: "json", document: mcp, merged: mergeLoreMcp(withBridge, installation.agent, paths) });
+            }
+        }
+    }
+    return { installations: [...installations], documents, mergedDocuments, mcpDocuments };
+}
+/**
+ * Install the hook runtime when an installation needs it, then write the
+ * merged files. Unchanged files are left alone; changed ones get a backup.
+ */
+async function writeAgentEntries(entries, paths, now) {
+    if (entries.installations.some((installation) => targetFor(installation.agent).runtimeRequired)) {
+        await installRuntime(paths);
+    }
+    const changedFiles = [];
+    const backups = [];
+    for (const [path, entry] of entries.mcpDocuments) {
+        const result = entry.kind === "json"
+            ? await writeMergedJson(path, entry.document, entry.merged, now)
+            : await writeMergedText(path, entry.document, entry.merged, now);
+        if (result.changed)
+            changedFiles.push(path);
+        if (result.backup)
+            backups.push(result.backup);
+    }
+    for (const installation of entries.installations) {
+        const key = installationKey(installation);
+        const document = entries.documents.get(key);
+        const merged = entries.mergedDocuments.get(key);
+        if (document === undefined || merged === undefined) {
+            continue;
+        }
+        const result = await writeMergedJson(installation.configPath, document, merged, now);
+        if (result.changed) {
+            changedFiles.push(installation.configPath);
+        }
+        if (result.backup !== undefined) {
+            backups.push(result.backup);
+        }
+    }
+    return { changedFiles, backups };
+}
+/**
+ * Re-apply the Lore-owned hook and MCP entries and the `lore` skill for the
+ * agents recorded in the stored connection, for example after `lore update`
+ * replaced the binary. Nothing is authorized again and folder rules are
+ * untouched. Resolves to null when no connection is stored.
+ */
+export async function refreshAgentEntries(paths = getLorePaths()) {
+    const config = await readConnectorConfig(paths);
+    if (config === null)
+        return null;
+    const installations = uniqueInstallations(configuredInstallations(config, paths));
+    return withDirectoryLock(resolve(paths.loreDirectory, "connections.lock"), async () => {
+        const entries = await prepareAgentEntries(installations, paths);
+        const written = await writeAgentEntries(entries, paths, new Date());
+        const skills = await installLoreSkill(paths, installations);
+        return {
+            // Same order the files are written in, so the two update lines match.
+            configFiles: [
+                ...entries.mcpDocuments.keys(),
+                ...installations.map((installation) => installation.configPath),
+            ],
+            ...written,
+            skillFiles: skills.files,
+            warnings: skills.warnings,
+        };
+    });
+}
 function countAgentIntegrations(input, agent) {
     const target = targetFor(agent);
     return target.count(input === undefined ? target.emptyValue() : input);
@@ -1773,20 +1931,9 @@ async function connectWithCredentialLocked(options, identity) {
         throw new Error("No Claude, Codex, Copilot CLI, Cursor, OpenCode, or Polytoken installation detected. Use --agent <name>; T3 Code users can use --agent t3code, and Devin CLI users --agent devin.");
     }
     const now = new Date();
-    const documents = new Map();
-    const mergedDocuments = new Map();
-    const cursorMcpDocuments = new Map();
-    for (const installation of installations) {
-        const key = installationKey(installation);
-        const document = await readJsonDocument(installation.configPath);
-        documents.set(key, document);
-        mergedDocuments.set(key, mergeAgentConfig(document.value, installation.agent, paths));
-        if (installation.agent === "cursor") {
-            const mcpPath = resolve(dirname(installation.configPath), "mcp.json");
-            const mcp = await readJsonDocument(mcpPath);
-            cursorMcpDocuments.set(mcpPath, { document: mcp, merged: mergeLoreCursorMcp(mcp.exists ? mcp.value : {}, paths) });
-        }
-    }
+    // Read and merge before anything is persisted so an unreadable agent file
+    // stops the run without a half-written connection.
+    const entries = await prepareAgentEntries(installations, paths);
     const agentConfigPaths = {};
     for (const agent of agents) {
         agentConfigPaths[agent] = installations
@@ -1812,33 +1959,7 @@ async function connectWithCredentialLocked(options, identity) {
     await reliabilityStore.initialize();
     // Folder restrictions must be durable before any new hook can run.
     await persistConnection(paths, config, connection.profiles);
-    if (installations.some((installation) => targetFor(installation.agent).runtimeRequired)) {
-        await installRuntime(paths);
-    }
-    const changedHookFiles = [];
-    const backups = [];
-    for (const [path, { document, merged }] of cursorMcpDocuments) {
-        const result = await writeMergedJson(path, document, merged, now);
-        if (result.changed)
-            changedHookFiles.push(path);
-        if (result.backup)
-            backups.push(result.backup);
-    }
-    for (const installation of installations) {
-        const key = installationKey(installation);
-        const document = documents.get(key);
-        const merged = mergedDocuments.get(key);
-        if (document === undefined || merged === undefined) {
-            continue;
-        }
-        const result = await writeMergedJson(installation.configPath, document, merged, now);
-        if (result.changed) {
-            changedHookFiles.push(installation.configPath);
-        }
-        if (result.backup !== undefined) {
-            backups.push(result.backup);
-        }
-    }
+    const { changedFiles: changedHookFiles, backups } = await writeAgentEntries(entries, paths, now);
     if (existing && !existing.connectionId && existing.apiUrl === apiUrl && existing.token === token) {
         await new ReliabilityStore(identity.workspaceId, { home: paths.home }).transferPendingTo(reliabilityStore);
         await reliabilityStore.migrateLegacyQueue(paths.queue);
@@ -2024,11 +2145,11 @@ async function acknowledgeDeviceAuthorization(apiUrl, authorization) {
 export function connectNextStep(agent) {
     switch (agent) {
         case "claude":
-            return "Restart Claude Code.";
+            return "Restart Claude Code and allow the lore MCP server when it asks.";
         case "codex":
             return "Restart Codex, open /hooks, approve Lore's hooks, then start a fresh session.";
         case "cursor":
-            return "Restart Cursor and enable the lore-native MCP server (lore_context and lore_complete).";
+            return "Restart Cursor and enable the lore-native and lore MCP servers.";
         case "opencode":
             return "Restart OpenCode.";
         case "copilot":
@@ -2350,13 +2471,30 @@ async function getAgentStatus(agent, config, paths, runtime) {
             units.push(...inspectInstallationUnits(document.value === undefined
                 ? target.emptyValue()
                 : document.value, agent, paths, index, configPaths.length));
-            if (agent === "cursor") {
-                const mcp = await readJsonDocument(resolve(dirname(path), "mcp.json"));
-                const value = isObject(mcp.value) && isObject(mcp.value.mcpServers) ? mcp.value.mcpServers[CURSOR_MCP_NAME] : undefined;
-                const owned = Number(isLoreCursorMcp(value));
-                installed += owned;
-                units.push({ id: installationUnitId("mcp", index, configPaths.length),
-                    state: installationUnitState(owned, Number(exactConfiguration(value, cursorMcpServer(paths)))) });
+            if (isMcpHostAgent(agent)) {
+                const mcpPath = mcpConfigPath(agent, path);
+                if (agent === "codex") {
+                    const state = inspectCodexMcp((await readTextDocument(mcpPath)).value, loreMcpServer(paths));
+                    installed += state.owned;
+                    units.push({ id: installationUnitId("mcp-tools", index, configPaths.length),
+                        state: installationUnitState(state.owned, Number(state.exact)) });
+                }
+                else {
+                    const mcp = await readJsonDocument(mcpPath);
+                    const servers = isObject(mcp.value) && isObject(mcp.value.mcpServers) ? mcp.value.mcpServers : {};
+                    if (agent === "cursor") {
+                        const bridge = servers[CURSOR_MCP_NAME];
+                        const owned = Number(isLoreCursorMcp(bridge));
+                        installed += owned;
+                        units.push({ id: installationUnitId("mcp", index, configPaths.length),
+                            state: installationUnitState(owned, Number(exactConfiguration(bridge, cursorMcpServer(paths)))) });
+                    }
+                    const value = servers[LORE_MCP_SERVER_NAME];
+                    const owned = Number(isLoreMcpServer(value));
+                    installed += owned;
+                    units.push({ id: installationUnitId("mcp-tools", index, configPaths.length),
+                        state: installationUnitState(owned, Number(exactConfiguration(value, loreMcpServer(paths)))) });
+                }
             }
         }
         catch {
@@ -2518,15 +2656,29 @@ export async function disconnectInstallation(paths = getLorePaths(), preservePen
     ]);
     for (const installation of installations) {
         const path = installation.configPath;
-        if (installation.agent === "cursor") {
-            const mcpPath = resolve(dirname(path), "mcp.json");
-            const mcp = await readJsonDocument(mcpPath);
-            if (mcp.exists) {
-                const result = await writeMergedJson(mcpPath, mcp, removeLoreCursorMcp(mcp.value), now);
-                if (result.changed)
-                    changedHookFiles.push(mcpPath);
-                if (result.backup)
-                    backups.push(result.backup);
+        if (isMcpHostAgent(installation.agent)) {
+            const mcpPath = mcpConfigPath(installation.agent, path);
+            if (installation.agent === "codex") {
+                const text = await readTextDocument(mcpPath);
+                if (text.exists) {
+                    const result = await writeMergedText(mcpPath, text, removeLoreCodexMcp(text.value), now);
+                    if (result.changed)
+                        changedHookFiles.push(mcpPath);
+                    if (result.backup)
+                        backups.push(result.backup);
+                }
+            }
+            else {
+                const mcp = await readJsonDocument(mcpPath);
+                if (mcp.exists) {
+                    const withoutTools = removeLoreMcp(mcp.value, installation.agent);
+                    const cleaned = installation.agent === "cursor" ? removeLoreCursorMcp(withoutTools) : withoutTools;
+                    const result = await writeMergedJson(mcpPath, mcp, cleaned, now);
+                    if (result.changed)
+                        changedHookFiles.push(mcpPath);
+                    if (result.backup)
+                        backups.push(result.backup);
+                }
             }
         }
         const document = await readJsonDocument(path);
@@ -2910,6 +3062,9 @@ async function printCommandHelp(path) {
         case "learnings":
             await runLearningsCommand(args, null);
             return;
+        case "review":
+            await runReviewCommand(args, null);
+            return;
         case "remember":
             await runRememberCommand(args, null);
             return;
@@ -2994,7 +3149,7 @@ async function executeCli(args = process.argv.slice(2)) {
     const helpIndex = args.findIndex((value, index) => index > 0 && (separator < 0 || index < separator) && (value === "--help" || value === "-h"));
     if (helpIndex > 0) {
         const subcommand = args[1];
-        const grouped = ["connect", "config", "embeddings", "guard", "recovery", "github", "devin", "host", "self-host", "scope"].includes(command ?? "");
+        const grouped = ["connect", "config", "embeddings", "guard", "recovery", "github", "devin", "host", "self-host", "scope", "review"].includes(command ?? "");
         await printCommandHelp([command, ...(grouped && subcommand && !subcommand.startsWith("-") ? [subcommand] : [])]);
         return;
     }
@@ -3007,7 +3162,7 @@ async function executeCli(args = process.argv.slice(2)) {
         return;
     }
     const commandArgs = args.slice(1);
-    if (["ask", "learnings", "remember", "share", "resume", "continue", "approach", "skill"].includes(command) && !(command === "skill" && commandArgs[0] === "discover")) {
+    if (["ask", "learnings", "review", "remember", "share", "resume", "continue", "approach", "skill"].includes(command) && !(command === "skill" && commandArgs[0] === "discover")) {
         const decision = await checkDirectory(process.cwd(), getLorePaths(["approach", "skill"].includes(command) ? process.env.LORE_HOME : undefined).home);
         if (!decision.allowed)
             throw new Error(`Lore is off in this folder. ${decision.reason}`);
@@ -3050,6 +3205,9 @@ async function executeCli(args = process.argv.slice(2)) {
         case "learnings":
             await runLearningsCommand(commandArgs, await readConnectorConfig(getLorePaths(), process.cwd()));
             return;
+        case "review":
+            await runReviewCommand(commandArgs, await readConnectorConfig(getLorePaths(), process.cwd()));
+            return;
         case "remember":
             await runRememberCommand(commandArgs, await readConnectorConfig(getLorePaths(), process.cwd()));
             return;
@@ -3164,6 +3322,10 @@ async function executeCli(args = process.argv.slice(2)) {
         case "cursor-mcp":
             await (await import("./cursor-mcp.js")).runCursorMcpServer();
             return;
+        case "mcp":
+            // The full Lore MCP server, registered by connect for hook-based agents.
+            await (await import("@lore-co/mcp")).runStdioServer();
+            return;
         case "internal-health-write": {
             const encoded = commandArgs[0] ?? (await readInvocationHealthWriteInput());
             await runInvocationHealthWrite(encoded);