code-session-memory 0.8.1 → 0.10.0

package/dist/src/cli.js

@@ -4,7 +4,7 @@
  * code-session-memory CLI
  *
  * Usage:
- *   npx code-session-memory install        — install for OpenCode + Claude Code
+ *   npx code-session-memory install        — install for all detected supported tools
  *   npx code-session-memory status         — show installation status
  *   npx code-session-memory uninstall      — remove all installed components
  *   npx code-session-memory reset-db       — wipe the database (with confirmation)
@@ -51,6 +51,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const clack = __importStar(require("@clack/prompts"));
+const smol_toml_1 = require("smol-toml");
 const database_1 = require("./database");
 const cli_sessions_1 = require("./cli-sessions");
 const cli_query_1 = require("./cli-query");
@@ -120,6 +121,12 @@ function getIndexerCliClaudePath() {
 function getIndexerCliCursorPath() {
     return path_1.default.join(getPackageRoot(), "dist", "src", "indexer-cli-cursor.js");
 }
+function getIndexerCliVscodePath() {
+    return path_1.default.join(getPackageRoot(), "dist", "src", "indexer-cli-vscode.js");
+}
+function getIndexerCliCodexPath() {
+    return path_1.default.join(getPackageRoot(), "dist", "src", "indexer-cli-codex.js");
+}
 // ---------------------------------------------------------------------------
 // Paths — Cursor
 // ---------------------------------------------------------------------------
@@ -142,8 +149,59 @@ function getCursorSkillDst() {
     return path_1.default.join(getCursorConfigDir(), "skills", "code-session-memory", "SKILL.md");
 }
 // ---------------------------------------------------------------------------
+// Paths — VS Code
+// ---------------------------------------------------------------------------
+function getVscodeConfigDir() {
+    const envDir = process.env.VSCODE_CONFIG_DIR;
+    if (envDir)
+        return envDir;
+    if (process.platform === "darwin") {
+        return path_1.default.join(os_1.default.homedir(), "Library", "Application Support", "Code", "User");
+    }
+    // Linux (and fallback)
+    return path_1.default.join(os_1.default.homedir(), ".config", "Code", "User");
+}
+function getVscodeSettingsPath() {
+    return path_1.default.join(getVscodeConfigDir(), "settings.json");
+}
+function getVscodeMcpConfigPath() {
+    return path_1.default.join(getVscodeConfigDir(), "mcp.json");
+}
+function getVscodeHooksPath() {
+    return path_1.default.join(getVscodeConfigDir(), "hooks", "code-session-memory.json");
+}
+// ---------------------------------------------------------------------------
+// Paths — Codex
+// ---------------------------------------------------------------------------
+function getCodexConfigDir() {
+    const envDir = process.env.CODEX_HOME;
+    if (envDir)
+        return envDir;
+    return path_1.default.join(os_1.default.homedir(), ".codex");
+}
+function getCodexConfigPath() {
+    return path_1.default.join(getCodexConfigDir(), "config.toml");
+}
+function getCodexSkillDst() {
+    return path_1.default.join(getCodexConfigDir(), "skills", "code-session-memory", "SKILL.md");
+}
+// ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
+/**
+ * Parse a JSONC string (JSON with comments and trailing commas).
+ * VS Code's settings.json uses JSONC, so we need this to read it safely.
+ */
+function parseJsonc(text) {
+    // Remove single-line comments (// ...)
+    // Remove multi-line comments (/* ... */)
+    // Remove trailing commas before } or ]
+    const stripped = text
+        .replace(/\/\/[^\n]*/g, "")
+        .replace(/\/\*[\s\S]*?\*\//g, "")
+        .replace(/,(\s*[}\]])/g, "$1");
+    return JSON.parse(stripped);
+}
 function ensureDir(dir) {
     fs_1.default.mkdirSync(dir, { recursive: true });
 }
@@ -613,7 +671,7 @@ function installCursorSkill(skillSrc) {
     const cursorFrontmatter = [
         "---",
         "name: code-session-memory",
-        "description: Search past AI coding sessions semantically across OpenCode, Claude Code, and Cursor. Use this when the user asks about past work, decisions, or implementations.",
+        "description: Search past AI coding sessions semantically across OpenCode, Claude Code, Cursor, VS Code, and Codex. Use this when the user asks about past work, decisions, or implementations.",
         "---",
         "",
     ].join("\n");
@@ -639,6 +697,385 @@ function uninstallCursorSkill() {
     return "done";
 }
 // ---------------------------------------------------------------------------
+// VS Code — hook
+// ---------------------------------------------------------------------------
+/**
+ * Installs the VS Code Stop hook at ~/.vscode/hooks/code-session-memory.json
+ * using the Copilot hook format.
+ */
+function installVscodeHook(indexerCliVscodePath) {
+    const hooksPath = getVscodeHooksPath();
+    const existed = fs_1.default.existsSync(hooksPath);
+    // Always overwrite with our hook config (this file is owned by us)
+    const config = {
+        hooks: {
+            Stop: [
+                {
+                    type: "command",
+                    command: `node ${indexerCliVscodePath}`,
+                },
+            ],
+        },
+    };
+    ensureDir(path_1.default.dirname(hooksPath));
+    fs_1.default.writeFileSync(hooksPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+    return { hooksPath, existed };
+}
+/**
+ * Removes the VS Code Stop hook file.
+ */
+function uninstallVscodeHook() {
+    const hooksPath = getVscodeHooksPath();
+    if (!fs_1.default.existsSync(hooksPath))
+        return "not_found";
+    fs_1.default.unlinkSync(hooksPath);
+    // Remove the directory if empty
+    try {
+        const dir = path_1.default.dirname(hooksPath);
+        if (fs_1.default.readdirSync(dir).length === 0)
+            fs_1.default.rmdirSync(dir);
+    }
+    catch { /* ignore */ }
+    return "done";
+}
+function checkVscodeHookInstalled() {
+    const hooksPath = getVscodeHooksPath();
+    try {
+        const config = JSON.parse(fs_1.default.readFileSync(hooksPath, "utf8"));
+        const stop = config.hooks?.Stop;
+        if (!Array.isArray(stop))
+            return false;
+        return stop.some((entry) => {
+            if (!entry || typeof entry !== "object")
+                return false;
+            const e = entry;
+            return typeof e.command === "string" && e.command.includes("indexer-cli-vscode");
+        });
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// VS Code — hook location registration
+// ---------------------------------------------------------------------------
+/**
+ * Returns the VS Code hooks path as a ~-prefixed string.
+ * VS Code supports ~ in hookFilesLocations, which improves portability across
+ * machines and avoids VS Code showing the fully-expanded path as an error.
+ */
+function getVscodeHooksPathTilde() {
+    const hooksPath = getVscodeHooksPath();
+    const home = os_1.default.homedir();
+    if (hooksPath.startsWith(home + path_1.default.sep)) {
+        return "~" + hooksPath.slice(home.length);
+    }
+    return hooksPath;
+}
+/**
+ * Adds the hook file path to VS Code's settings.json under
+ * `chat.hookFilesLocations` so VS Code discovers our hook.
+ * Uses a ~-prefixed path for portability.
+ */
+function installVscodeHookLocation() {
+    const settingsPath = getVscodeSettingsPath();
+    const existed = fs_1.default.existsSync(settingsPath);
+    let settings = {};
+    if (existed) {
+        try {
+            settings = parseJsonc(fs_1.default.readFileSync(settingsPath, "utf8"));
+        }
+        catch {
+            throw new Error(`Could not parse existing ${settingsPath} — please check it is valid JSON.`);
+        }
+    }
+    const hookLocations = (settings["chat.hookFilesLocations"] ?? {});
+    // Remove any previously installed absolute path entry (migration)
+    const absolutePath = getVscodeHooksPath();
+    if (absolutePath in hookLocations) {
+        delete hookLocations[absolutePath];
+    }
+    hookLocations[getVscodeHooksPathTilde()] = true;
+    settings["chat.hookFilesLocations"] = hookLocations;
+    ensureDir(path_1.default.dirname(settingsPath));
+    fs_1.default.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+    return { settingsPath, existed };
+}
+/**
+ * Removes our hook file path from VS Code's `chat.hookFilesLocations` setting.
+ * Handles both ~ and absolute path variants.
+ */
+function uninstallVscodeHookLocation() {
+    const settingsPath = getVscodeSettingsPath();
+    if (!fs_1.default.existsSync(settingsPath))
+        return "not_found";
+    try {
+        const settings = parseJsonc(fs_1.default.readFileSync(settingsPath, "utf8"));
+        const hookLocations = settings["chat.hookFilesLocations"];
+        if (!hookLocations)
+            return "not_found";
+        const tildePath = getVscodeHooksPathTilde();
+        const absolutePath = getVscodeHooksPath();
+        const foundTilde = tildePath in hookLocations;
+        const foundAbsolute = absolutePath in hookLocations;
+        if (!foundTilde && !foundAbsolute)
+            return "not_found";
+        if (foundTilde)
+            delete hookLocations[tildePath];
+        if (foundAbsolute)
+            delete hookLocations[absolutePath];
+        settings["chat.hookFilesLocations"] = hookLocations;
+        fs_1.default.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+        return "done";
+    }
+    catch {
+        return "not_found";
+    }
+}
+function checkVscodeHookLocationRegistered() {
+    const settingsPath = getVscodeSettingsPath();
+    try {
+        const settings = parseJsonc(fs_1.default.readFileSync(settingsPath, "utf8"));
+        const hookLocations = settings["chat.hookFilesLocations"];
+        if (!hookLocations)
+            return false;
+        return hookLocations[getVscodeHooksPathTilde()] === true ||
+            hookLocations[getVscodeHooksPath()] === true;
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// VS Code — MCP config
+// ---------------------------------------------------------------------------
+/**
+ * Merges the code-session-memory MCP entry into VS Code's mcp.json.
+ */
+function installVscodeMcpConfig(mcpServerPath) {
+    const configPath = getVscodeMcpConfigPath();
+    const existed = fs_1.default.existsSync(configPath);
+    let config = {};
+    if (existed) {
+        try {
+            config = JSON.parse(fs_1.default.readFileSync(configPath, "utf8"));
+        }
+        catch {
+            throw new Error(`Could not parse existing ${configPath} — please check it is valid JSON.`);
+        }
+    }
+    if (!config.servers || typeof config.servers !== "object")
+        config.servers = {};
+    config.servers["code-session-memory"] = {
+        type: "stdio",
+        command: "node",
+        args: [mcpServerPath],
+    };
+    ensureDir(path_1.default.dirname(configPath));
+    fs_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+    return { configPath, existed };
+}
+/**
+ * Removes the code-session-memory MCP entry from VS Code's mcp.json.
+ */
+function uninstallVscodeMcpConfig() {
+    const configPath = getVscodeMcpConfigPath();
+    if (!fs_1.default.existsSync(configPath))
+        return "not_found";
+    try {
+        const config = JSON.parse(fs_1.default.readFileSync(configPath, "utf8"));
+        if (config.servers &&
+            typeof config.servers === "object" &&
+            "code-session-memory" in config.servers) {
+            delete config.servers["code-session-memory"];
+            fs_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+            return "done";
+        }
+        return "not_found";
+    }
+    catch {
+        return "not_found";
+    }
+}
+function checkVscodeMcpConfigured() {
+    const configPath = getVscodeMcpConfigPath();
+    try {
+        const config = JSON.parse(fs_1.default.readFileSync(configPath, "utf8"));
+        return !!(config.servers &&
+            typeof config.servers === "object" &&
+            "code-session-memory" in config.servers);
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// Codex — config.toml (TOML)
+// ---------------------------------------------------------------------------
+function parseCodexConfigOrEmpty(configPath) {
+    if (!fs_1.default.existsSync(configPath))
+        return {};
+    try {
+        return (0, smol_toml_1.parse)(fs_1.default.readFileSync(configPath, "utf8"));
+    }
+    catch {
+        throw new Error(`Could not parse existing ${configPath} — please check it is valid TOML.`);
+    }
+}
+function mergeCodexEnvVarsPassthrough(existing) {
+    const values = Array.isArray(existing)
+        ? existing.filter((v) => typeof v === "string" && v.trim().length > 0)
+        : [];
+    if (!values.includes("OPENAI_API_KEY"))
+        values.push("OPENAI_API_KEY");
+    return values;
+}
+function installCodexMcpConfig(mcpServerPath) {
+    const configPath = getCodexConfigPath();
+    const existed = fs_1.default.existsSync(configPath);
+    const config = parseCodexConfigOrEmpty(configPath);
+    const mcpServersRaw = config.mcp_servers;
+    const mcpServers = mcpServersRaw && typeof mcpServersRaw === "object"
+        ? mcpServersRaw
+        : {};
+    const existingServer = mcpServers["code-session-memory"];
+    const serverConfig = existingServer && typeof existingServer === "object"
+        ? existingServer
+        : {};
+    mcpServers["code-session-memory"] = {
+        ...serverConfig,
+        command: "node",
+        args: [mcpServerPath],
+        // Codex MCP servers run with a restricted environment by default.
+        // Pass-through env vars are configured via env_vars (env is a map of fixed values).
+        env_vars: mergeCodexEnvVarsPassthrough(serverConfig.env_vars),
+    };
+    config.mcp_servers = mcpServers;
+    ensureDir(path_1.default.dirname(configPath));
+    fs_1.default.writeFileSync(configPath, (0, smol_toml_1.stringify)(config) + "\n", "utf8");
+    return { configPath, existed };
+}
+function uninstallCodexMcpConfig() {
+    const configPath = getCodexConfigPath();
+    if (!fs_1.default.existsSync(configPath))
+        return "not_found";
+    try {
+        const config = (0, smol_toml_1.parse)(fs_1.default.readFileSync(configPath, "utf8"));
+        const mcpServers = config.mcp_servers;
+        if (!mcpServers || !(Object.prototype.hasOwnProperty.call(mcpServers, "code-session-memory"))) {
+            return "not_found";
+        }
+        delete mcpServers["code-session-memory"];
+        fs_1.default.writeFileSync(configPath, (0, smol_toml_1.stringify)(config) + "\n", "utf8");
+        return "done";
+    }
+    catch {
+        return "not_found";
+    }
+}
+function checkCodexMcpConfigured() {
+    const configPath = getCodexConfigPath();
+    try {
+        const config = (0, smol_toml_1.parse)(fs_1.default.readFileSync(configPath, "utf8"));
+        const mcpServers = config.mcp_servers;
+        return !!(mcpServers && Object.prototype.hasOwnProperty.call(mcpServers, "code-session-memory"));
+    }
+    catch {
+        return false;
+    }
+}
+function checkCodexOpenAiPassthroughConfigured() {
+    const configPath = getCodexConfigPath();
+    try {
+        const config = (0, smol_toml_1.parse)(fs_1.default.readFileSync(configPath, "utf8"));
+        const mcpServers = config.mcp_servers;
+        const server = mcpServers?.["code-session-memory"];
+        if (!server || typeof server !== "object")
+            return false;
+        const envVars = server.env_vars;
+        return Array.isArray(envVars) && envVars.includes("OPENAI_API_KEY");
+    }
+    catch {
+        return false;
+    }
+}
+function installCodexHook(indexerCliCodexPath) {
+    const configPath = getCodexConfigPath();
+    const existed = fs_1.default.existsSync(configPath);
+    const config = parseCodexConfigOrEmpty(configPath);
+    config.notify = ["node", indexerCliCodexPath];
+    ensureDir(path_1.default.dirname(configPath));
+    fs_1.default.writeFileSync(configPath, (0, smol_toml_1.stringify)(config) + "\n", "utf8");
+    return { configPath, existed };
+}
+function uninstallCodexHook() {
+    const configPath = getCodexConfigPath();
+    if (!fs_1.default.existsSync(configPath))
+        return "not_found";
+    try {
+        const config = (0, smol_toml_1.parse)(fs_1.default.readFileSync(configPath, "utf8"));
+        const notify = config.notify;
+        if (!Array.isArray(notify))
+            return "not_found";
+        const hasOurHook = notify.some((v) => typeof v === "string" && v.includes("indexer-cli-codex"));
+        if (!hasOurHook)
+            return "not_found";
+        delete config.notify;
+        fs_1.default.writeFileSync(configPath, (0, smol_toml_1.stringify)(config) + "\n", "utf8");
+        return "done";
+    }
+    catch {
+        return "not_found";
+    }
+}
+function checkCodexHookInstalled() {
+    const configPath = getCodexConfigPath();
+    try {
+        const config = (0, smol_toml_1.parse)(fs_1.default.readFileSync(configPath, "utf8"));
+        const notify = config.notify;
+        if (!Array.isArray(notify))
+            return false;
+        return notify.some((v) => typeof v === "string" && v.includes("indexer-cli-codex"));
+    }
+    catch {
+        return false;
+    }
+}
+function installCodexSkill(skillSrc) {
+    const dstPath = getCodexSkillDst();
+    const existed = fs_1.default.existsSync(dstPath);
+    if (!fs_1.default.existsSync(skillSrc)) {
+        throw new Error(`Skill source not found: ${skillSrc}\nDid you run "npm run build" first?`);
+    }
+    const skillBody = fs_1.default.readFileSync(skillSrc, "utf8");
+    const bodyWithoutFrontmatter = skillBody
+        .replace(/^---[\s\S]*?---\s*\n?/, "")
+        .trimStart();
+    const codexFrontmatter = [
+        "---",
+        "name: code-session-memory",
+        "description: Search past AI coding sessions semantically across OpenCode, Claude Code, Cursor, VS Code, and Codex.",
+        "---",
+        "",
+    ].join("\n");
+    ensureDir(path_1.default.dirname(dstPath));
+    fs_1.default.writeFileSync(dstPath, codexFrontmatter + bodyWithoutFrontmatter, "utf8");
+    return { dstPath, existed };
+}
+function uninstallCodexSkill() {
+    const dstPath = getCodexSkillDst();
+    if (!fs_1.default.existsSync(dstPath))
+        return "not_found";
+    fs_1.default.unlinkSync(dstPath);
+    try {
+        const dir = path_1.default.dirname(dstPath);
+        if (fs_1.default.readdirSync(dir).length === 0)
+            fs_1.default.rmdirSync(dir);
+    }
+    catch { /* ignore */ }
+    return "done";
+}
+// ---------------------------------------------------------------------------
 // Formatting helpers
 // ---------------------------------------------------------------------------
 function bold(s) { return `\x1b[1m${s}\x1b[0m`; }
@@ -646,6 +1083,24 @@ function green(s) { return `\x1b[32m${s}\x1b[0m`; }
 function red(s) { return `\x1b[31m${s}\x1b[0m`; }
 function dim(s) { return `\x1b[2m${s}\x1b[0m`; }
 function ok(v) { return v ? green("✓") : red("✗"); }
+// ---------------------------------------------------------------------------
+// Tool detection
+// ---------------------------------------------------------------------------
+function isOpenCodeInstalled() {
+    return fs_1.default.existsSync(getOpenCodeConfigDir());
+}
+function isClaudeCodeInstalled() {
+    return fs_1.default.existsSync(getClaudeConfigDir());
+}
+function isCursorInstalled() {
+    return fs_1.default.existsSync(getCursorConfigDir());
+}
+function isVscodeInstalled() {
+    return fs_1.default.existsSync(getVscodeConfigDir());
+}
+function isCodexInstalled() {
+    return fs_1.default.existsSync(getCodexConfigDir());
+}
 function step(label, fn) {
     process.stdout.write(`  ${label}... `);
     try {
@@ -658,6 +1113,13 @@ function step(label, fn) {
         process.exit(1);
     }
 }
+function stepIf(condition, label, fn) {
+    if (!condition) {
+        console.log(`  ${dim("○")}  ${dim(label)}  ${dim("(tool not detected — skipped)")}`);
+        return;
+    }
+    step(label, fn);
+}
 // ---------------------------------------------------------------------------
 // Commands
 // ---------------------------------------------------------------------------
@@ -667,6 +1129,13 @@ function install() {
     const mcpPath = getMcpServerPath();
     const indexerClaudePath = getIndexerCliClaudePath();
     const indexerCursorPath = getIndexerCliCursorPath();
+    const indexerVscodePath = getIndexerCliVscodePath();
+    const indexerCodexPath = getIndexerCliCodexPath();
+    const openCodeInstalled = isOpenCodeInstalled();
+    const claudeInstalled = isClaudeCodeInstalled();
+    const cursorInstalled = isCursorInstalled();
+    const vscodeInstalled = isVscodeInstalled();
+    const codexInstalled = isCodexInstalled();
     // 1. DB
     step("Initialising database", () => {
         ensureDir(path_1.default.dirname(dbPath));
@@ -674,53 +1143,73 @@ function install() {
         db.close();
         return dbPath;
     });
-    // 2. OpenCode plugin
-    step("Installing OpenCode plugin", () => {
+    // OpenCode
+    stepIf(openCodeInstalled, "Installing OpenCode plugin", () => {
         const dst = getOpenCodePluginDst();
         installOpenCodePlugin(getPluginSrc(), dst);
         return dst;
     });
-    // 3. OpenCode skill
-    step("Installing OpenCode skill", () => {
+    stepIf(openCodeInstalled, "Installing OpenCode skill", () => {
         const dst = getOpenCodeSkillDst();
         copyFile(getSkillSrc(), dst);
         return dst;
     });
-    // 4. OpenCode MCP config
-    step("Configuring OpenCode MCP server", () => {
+    stepIf(openCodeInstalled, "Configuring OpenCode MCP server", () => {
         const { configPath, existed } = installOpenCodeMcpConfig(mcpPath);
         return `${existed ? "updated" : "created"} ${configPath}`;
     });
-    // 5. Claude Code MCP config
-    step("Configuring Claude Code MCP server", () => {
+    // Claude Code
+    stepIf(claudeInstalled, "Configuring Claude Code MCP server", () => {
         const { configPath, existed } = installClaudeMcpConfig(mcpPath);
         return `${existed ? "updated" : "created"} ${configPath}`;
     });
-    // 6. Claude Code hook
-    step("Installing Claude Code Stop hook", () => {
+    stepIf(claudeInstalled, "Installing Claude Code Stop hook", () => {
         const { settingsPath, existed } = installClaudeHook(indexerClaudePath);
         return `${existed ? "updated" : "created"} ${settingsPath}`;
     });
-    // 7. Claude Code CLAUDE.md
-    step("Installing Claude Code context (CLAUDE.md)", () => {
+    stepIf(claudeInstalled, "Installing Claude Code context (CLAUDE.md)", () => {
         const { mdPath, existed } = installClaudeMd(getSkillSrc());
         return `${existed ? "updated" : "created"} ${mdPath}`;
     });
-    // 8. Cursor MCP config
-    step("Configuring Cursor MCP server", () => {
+    // Cursor
+    stepIf(cursorInstalled, "Configuring Cursor MCP server", () => {
         const { configPath, existed } = installCursorMcpConfig(mcpPath);
         return `${existed ? "updated" : "created"} ${configPath}`;
     });
-    // 9. Cursor stop hook
-    step("Installing Cursor stop hook", () => {
+    stepIf(cursorInstalled, "Installing Cursor stop hook", () => {
         const { hooksPath, existed } = installCursorHook(indexerCursorPath);
         return `${existed ? "updated" : "created"} ${hooksPath}`;
     });
-    // 10. Cursor skill
-    step("Installing Cursor skill", () => {
+    stepIf(cursorInstalled, "Installing Cursor skill", () => {
         const { dstPath, existed } = installCursorSkill(getSkillSrc());
         return `${existed ? "updated" : "created"} ${dstPath}`;
     });
+    // VS Code
+    stepIf(vscodeInstalled, "Configuring VS Code MCP server", () => {
+        const { configPath, existed } = installVscodeMcpConfig(mcpPath);
+        return `${existed ? "updated" : "created"} ${configPath}`;
+    });
+    stepIf(vscodeInstalled, "Installing VS Code Stop hook", () => {
+        const { hooksPath, existed } = installVscodeHook(indexerVscodePath);
+        return `${existed ? "updated" : "created"} ${hooksPath}`;
+    });
+    stepIf(vscodeInstalled, "Registering VS Code hook location", () => {
+        const { settingsPath, existed } = installVscodeHookLocation();
+        return `${existed ? "updated" : "created"} ${settingsPath}`;
+    });
+    // Codex
+    stepIf(codexInstalled, "Configuring Codex MCP server", () => {
+        const { configPath, existed } = installCodexMcpConfig(mcpPath);
+        return `${existed ? "updated" : "created"} ${configPath}`;
+    });
+    stepIf(codexInstalled, "Installing Codex notify hook", () => {
+        const { configPath, existed } = installCodexHook(indexerCodexPath);
+        return `${existed ? "updated" : "created"} ${configPath}`;
+    });
+    stepIf(codexInstalled, "Installing Codex skill", () => {
+        const { dstPath, existed } = installCodexSkill(getSkillSrc());
+        return `${existed ? "updated" : "created"} ${dstPath}`;
+    });
     console.log(`
 ${bold("Installation complete!")}
 
@@ -729,7 +1218,10 @@ ${bold("Required environment variable:")}
 
 ${bold("Default DB path:")} ${dbPath}
 
-Restart ${bold("OpenCode")}, ${bold("Claude Code")}, and ${bold("Cursor")} to activate.
+Restart ${bold("OpenCode")}, ${bold("Claude Code")}, ${bold("Cursor")}, ${bold("VS Code")}, and ${bold("Codex")} to activate.
+
+${bold("VS Code note:")} Ensure ${bold("Chat: Use Hooks")} is enabled in VS Code settings.
+${bold("Codex note:")} The notify hook and OPENAI_API_KEY passthrough are set in ${dim(getCodexConfigPath())}.
 Run ${bold("npx code-session-memory status")} to verify.
 `);
 }
@@ -737,18 +1229,57 @@ function status() {
     console.log(bold("\ncode-session-memory status\n"));
     const dbPath = (0, database_1.resolveDbPath)();
     const mcpPath = getMcpServerPath();
-    console.log(bold("  OpenCode"));
-    console.log(`  ${ok(fs_1.default.existsSync(getOpenCodePluginDst()))}  Plugin      ${dim(getOpenCodePluginDst())}`);
-    console.log(`  ${ok(fs_1.default.existsSync(getOpenCodeSkillDst()))}  Skill       ${dim(getOpenCodeSkillDst())}`);
-    console.log(`  ${ok(checkMcpConfigured())}  MCP config  ${dim(getGlobalOpenCodeConfigPath())}`);
-    console.log(bold("\n  Claude Code"));
-    console.log(`  ${ok(checkClaudeMcpConfigured())}  MCP config  ${dim(getClaudeUserConfigPath())}`);
-    console.log(`  ${ok(checkClaudeHookInstalled())}  Stop hook   ${dim(getClaudeSettingsPath())}`);
-    console.log(`  ${ok(checkClaudeMdInstalled())}  CLAUDE.md   ${dim(getClaudeMdPath())}`);
-    console.log(bold("\n  Cursor"));
-    console.log(`  ${ok(checkCursorMcpConfigured())}  MCP config  ${dim(getCursorMcpConfigPath())}`);
-    console.log(`  ${ok(checkCursorHookInstalled())}  Stop hook   ${dim(getCursorHooksPath())}`);
-    console.log(`  ${ok(fs_1.default.existsSync(getCursorSkillDst()))}  Skill       ${dim(getCursorSkillDst())}`);
+    const openCodeInstalled = isOpenCodeInstalled();
+    const claudeInstalled = isClaudeCodeInstalled();
+    const cursorInstalled = isCursorInstalled();
+    const vscodeInstalled = isVscodeInstalled();
+    const codexInstalled = isCodexInstalled();
+    if (openCodeInstalled) {
+        console.log(bold("  OpenCode"));
+        console.log(`  ${ok(fs_1.default.existsSync(getOpenCodePluginDst()))}  Plugin      ${dim(getOpenCodePluginDst())}`);
+        console.log(`  ${ok(fs_1.default.existsSync(getOpenCodeSkillDst()))}  Skill       ${dim(getOpenCodeSkillDst())}`);
+        console.log(`  ${ok(checkMcpConfigured())}  MCP config  ${dim(getGlobalOpenCodeConfigPath())}`);
+    }
+    else {
+        console.log(bold("  OpenCode") + dim("  (not installed — skipped)"));
+    }
+    if (claudeInstalled) {
+        console.log(bold("\n  Claude Code"));
+        console.log(`  ${ok(checkClaudeMcpConfigured())}  MCP config  ${dim(getClaudeUserConfigPath())}`);
+        console.log(`  ${ok(checkClaudeHookInstalled())}  Stop hook   ${dim(getClaudeSettingsPath())}`);
+        console.log(`  ${ok(checkClaudeMdInstalled())}  CLAUDE.md   ${dim(getClaudeMdPath())}`);
+    }
+    else {
+        console.log(bold("\n  Claude Code") + dim("  (not installed — skipped)"));
+    }
+    if (cursorInstalled) {
+        console.log(bold("\n  Cursor"));
+        console.log(`  ${ok(checkCursorMcpConfigured())}  MCP config  ${dim(getCursorMcpConfigPath())}`);
+        console.log(`  ${ok(checkCursorHookInstalled())}  Stop hook   ${dim(getCursorHooksPath())}`);
+        console.log(`  ${ok(fs_1.default.existsSync(getCursorSkillDst()))}  Skill       ${dim(getCursorSkillDst())}`);
+    }
+    else {
+        console.log(bold("\n  Cursor") + dim("  (not installed — skipped)"));
+    }
+    if (vscodeInstalled) {
+        console.log(bold("\n  VS Code"));
+        console.log(`  ${ok(checkVscodeMcpConfigured())}  MCP config  ${dim(getVscodeMcpConfigPath())}`);
+        console.log(`  ${ok(checkVscodeHookInstalled())}  Stop hook   ${dim(getVscodeHooksPath())}`);
+        console.log(`  ${ok(checkVscodeHookLocationRegistered())}  Hook loc    ${dim(getVscodeSettingsPath())}`);
+    }
+    else {
+        console.log(bold("\n  VS Code") + dim("  (not installed — skipped)"));
+    }
+    if (codexInstalled) {
+        console.log(bold("\n  Codex"));
+        console.log(`  ${ok(checkCodexMcpConfigured())}  MCP config  ${dim(getCodexConfigPath())}`);
+        console.log(`  ${ok(checkCodexOpenAiPassthroughConfigured())}  OPENAI_KEY ${dim(getCodexConfigPath())}`);
+        console.log(`  ${ok(checkCodexHookInstalled())}  Notify hook ${dim(getCodexConfigPath())}`);
+        console.log(`  ${ok(fs_1.default.existsSync(getCodexSkillDst()))}  Skill       ${dim(getCodexSkillDst())}`);
+    }
+    else {
+        console.log(bold("\n  Codex") + dim("  (not installed — skipped)"));
+    }
     console.log(bold("\n  Shared"));
     console.log(`  ${ok(fs_1.default.existsSync(mcpPath))}  MCP server  ${dim(mcpPath)}`);
     console.log(`  ${ok(fs_1.default.existsSync(dbPath))}  Database    ${dim(dbPath)}`);
@@ -772,15 +1303,22 @@ function status() {
         }
         catch { /* DB might be empty */ }
     }
-    const allOk = fs_1.default.existsSync(getOpenCodePluginDst()) &&
+    const allOk = (!openCodeInstalled || (fs_1.default.existsSync(getOpenCodePluginDst()) &&
         fs_1.default.existsSync(getOpenCodeSkillDst()) &&
-        checkMcpConfigured() &&
-        checkClaudeMcpConfigured() &&
-        checkClaudeHookInstalled() &&
-        checkClaudeMdInstalled() &&
-        checkCursorMcpConfigured() &&
-        checkCursorHookInstalled() &&
-        fs_1.default.existsSync(getCursorSkillDst()) &&
+        checkMcpConfigured())) &&
+        (!claudeInstalled || (checkClaudeMcpConfigured() &&
+            checkClaudeHookInstalled() &&
+            checkClaudeMdInstalled())) &&
+        (!cursorInstalled || (checkCursorMcpConfigured() &&
+            checkCursorHookInstalled() &&
+            fs_1.default.existsSync(getCursorSkillDst()))) &&
+        (!vscodeInstalled || (checkVscodeMcpConfigured() &&
+            checkVscodeHookInstalled() &&
+            checkVscodeHookLocationRegistered())) &&
+        (!codexInstalled || (checkCodexMcpConfigured() &&
+            checkCodexOpenAiPassthroughConfigured() &&
+            checkCodexHookInstalled() &&
+            fs_1.default.existsSync(getCodexSkillDst()))) &&
         fs_1.default.existsSync(mcpPath) &&
         fs_1.default.existsSync(dbPath);
     console.log(`\n  ${allOk
@@ -832,6 +1370,30 @@ function uninstall() {
                 if (uninstallCursorSkill() === "not_found")
                     throw new Error("not found");
             }],
+        ["VS Code MCP config", () => {
+                if (uninstallVscodeMcpConfig() === "not_found")
+                    throw new Error("not found");
+            }],
+        ["VS Code Stop hook", () => {
+                if (uninstallVscodeHook() === "not_found")
+                    throw new Error("not found");
+            }],
+        ["VS Code hook location", () => {
+                if (uninstallVscodeHookLocation() === "not_found")
+                    throw new Error("not found");
+            }],
+        ["Codex MCP config", () => {
+                if (uninstallCodexMcpConfig() === "not_found")
+                    throw new Error("not found");
+            }],
+        ["Codex notify hook", () => {
+                if (uninstallCodexHook() === "not_found")
+                    throw new Error("not found");
+            }],
+        ["Codex skill", () => {
+                if (uninstallCodexSkill() === "not_found")
+                    throw new Error("not found");
+            }],
     ];
     for (const [label, fn] of items) {
         process.stdout.write(`  Removing ${label}... `);
@@ -886,15 +1448,15 @@ async function resetDb() {
 }
 function help() {
     console.log(`
-${bold("code-session-memory")} — Shared vector memory for OpenCode, Claude Code, and Cursor sessions
+${bold("code-session-memory")} — Shared vector memory for OpenCode, Claude Code, Cursor, VS Code, and Codex sessions
 
 ${bold("Usage:")}
-  npx code-session-memory install                         Install all components (OpenCode + Claude Code + Cursor)
+  npx code-session-memory install                         Install components for detected tools
   npx code-session-memory status                          Show installation status and DB stats
   npx code-session-memory uninstall                       Remove all installed components (keeps DB)
   npx code-session-memory reset-db                        Delete all indexed data (keeps installation)
   npx code-session-memory query <text>                    Semantic search across all indexed sessions
-  npx code-session-memory query <text> --source <s>       Filter by source (opencode, claude-code, cursor)
+  npx code-session-memory query <text> --source <s>       Filter by source (opencode, claude-code, cursor, vscode, codex)
   npx code-session-memory query <text> --limit <n>        Max results (default: 5)
   npx code-session-memory query <text> --from <date>      Results from date (e.g. 2026-02-01)
   npx code-session-memory query <text> --to <date>        Results up to date (e.g. 2026-02-20)
@@ -911,6 +1473,8 @@ ${bold("Environment variables:")}
   OPENCODE_CONFIG_DIR       Override the OpenCode config directory
   CLAUDE_CONFIG_DIR         Override the Claude Code config directory
   CURSOR_CONFIG_DIR         Override the Cursor config directory (~/.cursor)
+  VSCODE_CONFIG_DIR         Override the VS Code config directory
+  CODEX_HOME                Override the Codex home directory (~/.codex)
 `);
 }
 // ---------------------------------------------------------------------------