code-session-memory 0.9.0 → 0.11.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");
@@ -123,6 +124,9 @@ function getIndexerCliCursorPath() {
 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
 // ---------------------------------------------------------------------------
@@ -167,6 +171,21 @@ 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
 // ---------------------------------------------------------------------------
 /**
@@ -652,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");
@@ -891,6 +910,172 @@ function checkVscodeMcpConfigured() {
     }
 }
 // ---------------------------------------------------------------------------
+// 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`; }
@@ -898,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 {
@@ -910,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
 // ---------------------------------------------------------------------------
@@ -920,6 +1130,12 @@ function install() {
     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));
@@ -927,68 +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}`;
     });
-    // 11. VS Code MCP config
-    step("Configuring VS Code MCP server", () => {
+    // VS Code
+    stepIf(vscodeInstalled, "Configuring VS Code MCP server", () => {
         const { configPath, existed } = installVscodeMcpConfig(mcpPath);
         return `${existed ? "updated" : "created"} ${configPath}`;
     });
-    // 12. VS Code Stop hook
-    step("Installing VS Code Stop hook", () => {
+    stepIf(vscodeInstalled, "Installing VS Code Stop hook", () => {
         const { hooksPath, existed } = installVscodeHook(indexerVscodePath);
         return `${existed ? "updated" : "created"} ${hooksPath}`;
     });
-    // 13. VS Code hook location registration
-    step("Registering VS Code hook location", () => {
+    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!")}
 
@@ -997,9 +1218,10 @@ ${bold("Required environment variable:")}
 
 ${bold("Default DB path:")} ${dbPath}
 
-Restart ${bold("OpenCode")}, ${bold("Claude Code")}, ${bold("Cursor")}, and ${bold("VS Code")} 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.
 `);
 }
@@ -1007,22 +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())}`);
-    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())}`);
+    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)}`);
@@ -1046,18 +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()) &&
-        checkVscodeMcpConfigured() &&
-        checkVscodeHookInstalled() &&
-        checkVscodeHookLocationRegistered() &&
+        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
@@ -1121,6 +1382,18 @@ function uninstall() {
                 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}... `);
@@ -1175,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)
@@ -1200,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)
 `);
 }
 // ---------------------------------------------------------------------------