codiedev 0.5.6 → 0.6.1

package/dist/commands/doctor.js

@@ -44,6 +44,9 @@ const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json")
 const CLAUDE_INSTRUCTIONS_PATH = path.join(os.homedir(), ".claude", "CLAUDE.md");
 const CODEX_HOOKS_PATH = path.join(os.homedir(), ".codex", "hooks.json");
 const CODEX_INSTRUCTIONS_PATH = path.join(os.homedir(), ".codex", "AGENTS.md");
+const CURSOR_HOOKS_PATH = path.join(os.homedir(), ".cursor", "hooks.json");
+const CURSOR_INSTRUCTIONS_PATH = path.join(os.homedir(), ".cursor", "rules", "codiedev.mdc");
+const CURSOR_MCP_PATH = path.join(os.homedir(), ".cursor", "mcp.json");
 function symbol(status) {
     if (status === "pass")
         return "✓";
@@ -57,6 +60,48 @@ function claudeCodeInstalled() {
 function codexInstalled() {
     return fs.existsSync(path.join(os.homedir(), ".codex"));
 }
+function cursorInstalled() {
+    return fs.existsSync(path.join(os.homedir(), ".cursor"));
+}
+function hasCursorMcpEntry() {
+    try {
+        if (!fs.existsSync(CURSOR_MCP_PATH))
+            return false;
+        const raw = fs.readFileSync(CURSOR_MCP_PATH, "utf8");
+        const parsed = JSON.parse(raw);
+        const servers = parsed.mcpServers;
+        return !!servers && "codiedev" in servers;
+    }
+    catch {
+        return false;
+    }
+}
+// Match both legacy `npx codiedev-hook ...` and absolute-path forms
+// `<node> <.../codiedev/dist/hook.js> ...` — installer switched to absolute
+// paths in 0.6.1 to work in GUI-launched contexts where shell PATH is missing.
+function isCodiedevHookCommand(cmd) {
+    if (!cmd)
+        return false;
+    return cmd.includes("codiedev-hook") || /codiedev[\\/]dist[\\/]hook/.test(cmd);
+}
+// Cursor's hooks.json schema is { hooks: { sessionEnd: [{ command, ... }] } }
+// — flat array of objects with `command`, not the Claude/Codex nested
+// `{ hooks: [{ command }] }` wrapper.
+function hasCursorHook() {
+    try {
+        if (!fs.existsSync(CURSOR_HOOKS_PATH))
+            return false;
+        const raw = fs.readFileSync(CURSOR_HOOKS_PATH, "utf8");
+        const parsed = JSON.parse(raw);
+        const arr = parsed.hooks?.sessionEnd;
+        if (!Array.isArray(arr))
+            return false;
+        return arr.some((h) => isCodiedevHookCommand(h.command));
+    }
+    catch {
+        return false;
+    }
+}
 function hasCodiedevHook(settingsPath, hookKey) {
     try {
         if (!fs.existsSync(settingsPath))
@@ -70,7 +115,7 @@ function hasCodiedevHook(settingsPath, hookKey) {
             const inner = h.hooks;
             if (!Array.isArray(inner))
                 return false;
-            return inner.some((x) => (x.command ?? "").includes("codiedev-hook"));
+            return inner.some((x) => isCodiedevHookCommand(x.command));
         });
     }
     catch {
@@ -229,7 +274,43 @@ async function runDoctor(_args) {
             detail: "not installed on this machine",
         });
     }
-    // 7. gh CLI (optional — only needed for reverse-ticket)
+    // 7. Cursor setup (if present)
+    if (cursorInstalled()) {
+        checks.push({
+            name: "Cursor detected",
+            status: "pass",
+            detail: "~/.cursor",
+        });
+        checks.push({
+            name: "Cursor sessionEnd hook",
+            status: hasCursorHook() ? "pass" : "fail",
+            detail: hasCursorHook()
+                ? "~/.cursor/hooks.json"
+                : "missing — re-run `codiedev connect`",
+        });
+        checks.push({
+            name: "Cursor agent instructions",
+            status: hasCodiedevInstructions(CURSOR_INSTRUCTIONS_PATH) ? "pass" : "fail",
+            detail: hasCodiedevInstructions(CURSOR_INSTRUCTIONS_PATH)
+                ? "~/.cursor/rules/codiedev.mdc"
+                : "missing — re-run `codiedev connect`",
+        });
+        checks.push({
+            name: "Cursor MCP server",
+            status: hasCursorMcpEntry() ? "pass" : "fail",
+            detail: hasCursorMcpEntry()
+                ? "~/.cursor/mcp.json"
+                : "missing — re-run `codiedev connect`",
+        });
+    }
+    else {
+        checks.push({
+            name: "Cursor",
+            status: "warn",
+            detail: "not installed on this machine",
+        });
+    }
+    // 8. gh CLI (optional — only needed for reverse-ticket)
     checks.push({
         name: "GitHub CLI (`gh`) for reverse-ticket command",
         status: hasGhCli() ? "pass" : "warn",

package/dist/connect.js

@@ -141,6 +141,7 @@ async function runConnect() {
     }
     const hasClaude = (0, utils_1.claudeCodeInstalled)();
     const hasCodex = (0, utils_1.codexInstalled)();
+    const hasCursor = (0, utils_1.cursorInstalled)();
     const installed = [];
     if (hasClaude) {
         try {
@@ -157,6 +158,13 @@ async function runConnect() {
         catch (err) {
             console.error(`\nWarning: Failed to install Claude Code instructions — ${err.message}`);
         }
+        try {
+            (0, utils_1.installClaudeCodeMcp)();
+            installed.push("Claude Code MCP server (~/.claude.json)");
+        }
+        catch (err) {
+            console.error(`\nWarning: Failed to install Claude Code MCP server — ${err.message}`);
+        }
     }
     if (hasCodex) {
         try {
@@ -173,9 +181,39 @@ async function runConnect() {
         catch (err) {
             console.error(`\nWarning: Failed to install Codex instructions — ${err.message}`);
         }
+        try {
+            (0, utils_1.installCodexMcp)();
+            installed.push("Codex MCP server (~/.codex/config.toml)");
+        }
+        catch (err) {
+            console.error(`\nWarning: Failed to install Codex MCP server — ${err.message}`);
+        }
+    }
+    if (hasCursor) {
+        try {
+            (0, utils_1.installCursorHook)();
+            installed.push("Cursor sessionEnd hook (~/.cursor/hooks.json)");
+        }
+        catch (err) {
+            console.error(`\nWarning: Failed to install Cursor hook — ${err.message}`);
+        }
+        try {
+            (0, utils_1.installCursorInstructions)();
+            installed.push("Cursor agent instructions (~/.cursor/rules/codiedev.mdc)");
+        }
+        catch (err) {
+            console.error(`\nWarning: Failed to install Cursor instructions — ${err.message}`);
+        }
+        try {
+            (0, utils_1.installCursorMcp)();
+            installed.push("Cursor MCP server (~/.cursor/mcp.json)");
+        }
+        catch (err) {
+            console.error(`\nWarning: Failed to install Cursor MCP server — ${err.message}`);
+        }
     }
-    if (!hasClaude && !hasCodex) {
-        console.warn("\nNo Claude Code (~/.claude) or Codex (~/.codex) install detected.");
+    if (!hasClaude && !hasCodex && !hasCursor) {
+        console.warn("\nNo Claude Code (~/.claude), Codex (~/.codex), or Cursor (~/.cursor) install detected.");
         console.warn("Config saved. Install one, then re-run `npx codiedev connect` to wire up capture hooks.");
     }
     console.log(`\nConnected to ${companyName}`);

package/dist/hook.js

@@ -87,6 +87,8 @@ async function readStdin() {
 function resolveMode(arg) {
     if (arg === "capture-codex")
         return "codex";
+    if (arg === "capture-cursor")
+        return "cursor";
     return "claude-code";
 }
 async function main() {
@@ -101,7 +103,10 @@ async function main() {
     catch {
         process.exit(0);
     }
-    const { session_id, transcript_path, cwd } = hookInput;
+    const { session_id, transcript_path, cwd, workspace_roots } = hookInput;
+    const workspaceRoot = workspace_roots && workspace_roots.length > 0
+        ? workspace_roots[0]
+        : cwd || process.cwd();
     const config = (0, utils_1.readConfig)();
     if (!config) {
         process.exit(0);
@@ -116,13 +121,14 @@ async function main() {
     catch {
         process.exit(0);
     }
-    // Resolve repo URL. Codex embeds it in session_meta; fall back to git for CC.
+    // Resolve repo URL. Codex embeds it in session_meta; CC and Cursor both
+    // need the git remote of the workspace.
     let remoteUrl = null;
     if (mode === "codex") {
         remoteUrl = (0, utils_1.extractCodexRepoUrl)(transcriptContent);
     }
     if (!remoteUrl) {
-        remoteUrl = (0, utils_1.getGitRemoteUrl)(cwd || process.cwd());
+        remoteUrl = (0, utils_1.getGitRemoteUrl)(workspaceRoot);
     }
     if (!remoteUrl) {
         process.exit(0);
@@ -131,9 +137,14 @@ async function main() {
     if (!matchedRepo) {
         process.exit(0);
     }
+    // Cursor's transcript format is undocumented — skip stats parsing for now
+    // and let the backend handle it once we have a real session to inspect.
+    // The transcript itself still uploads.
     const stats = mode === "codex"
         ? (0, utils_1.parseCodexStats)(transcriptContent)
-        : (0, utils_1.parseClaudeCodeStats)(transcriptContent);
+        : mode === "cursor"
+            ? { messageCount: 0, toolCallCount: 0 }
+            : (0, utils_1.parseClaudeCodeStats)(transcriptContent);
     const transcriptBase64 = Buffer.from(transcriptContent, "utf8").toString("base64");
     const payload = {
         sessionId: session_id,

package/dist/utils.d.ts

@@ -26,14 +26,23 @@ export declare function matchRepo(remoteUrl: string, repos: Array<{
 export declare function hashToken(token: string): string;
 export declare function claudeCodeInstalled(): boolean;
 export declare function codexInstalled(): boolean;
+export declare function cursorInstalled(): boolean;
 export declare function installHook(): void;
 export declare function installClaudeCodeInstructions(): void;
 export declare function installCodexInstructions(): void;
+export declare function installCursorInstructions(): void;
 /**
  * Install the CodieDev MCP server into Claude Code's user-scope config.
  * Safe to call multiple times — updates the existing entry if present.
  */
 export declare function installClaudeCodeMcp(): void;
+/**
+ * Install the CodieDev MCP server into Cursor's user-scope config.
+ * Cursor uses the same `mcpServers` schema as Claude Code; just a different
+ * file path (~/.cursor/mcp.json). Project-scoped servers can also live at
+ * <project>/.cursor/mcp.json — we only manage the user-scope one.
+ */
+export declare function installCursorMcp(): void;
 /**
  * Best-effort append of the CodieDev MCP server block to ~/.codex/config.toml.
  *
@@ -42,6 +51,7 @@ export declare function installClaudeCodeMcp(): void;
  */
 export declare function installCodexMcp(): boolean;
 export declare function installCodexHook(): void;
+export declare function installCursorHook(): void;
 export interface ParsedStats {
     messageCount: number;
     toolCallCount: number;

package/dist/utils.js

@@ -41,12 +41,16 @@ exports.matchRepo = matchRepo;
 exports.hashToken = hashToken;
 exports.claudeCodeInstalled = claudeCodeInstalled;
 exports.codexInstalled = codexInstalled;
+exports.cursorInstalled = cursorInstalled;
 exports.installHook = installHook;
 exports.installClaudeCodeInstructions = installClaudeCodeInstructions;
 exports.installCodexInstructions = installCodexInstructions;
+exports.installCursorInstructions = installCursorInstructions;
 exports.installClaudeCodeMcp = installClaudeCodeMcp;
+exports.installCursorMcp = installCursorMcp;
 exports.installCodexMcp = installCodexMcp;
 exports.installCodexHook = installCodexHook;
+exports.installCursorHook = installCursorHook;
 exports.parseClaudeCodeStats = parseClaudeCodeStats;
 exports.parseCodexStats = parseCodexStats;
 exports.extractCodexRepoUrl = extractCodexRepoUrl;
@@ -133,12 +137,50 @@ const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json")
 const CLAUDE_DIR = path.join(os.homedir(), ".claude");
 const CODEX_HOOKS_PATH = path.join(os.homedir(), ".codex", "hooks.json");
 const CODEX_DIR = path.join(os.homedir(), ".codex");
+const CURSOR_DIR = path.join(os.homedir(), ".cursor");
+const CURSOR_HOOKS_PATH = path.join(CURSOR_DIR, "hooks.json");
+const CURSOR_MCP_PATH = path.join(CURSOR_DIR, "mcp.json");
+const CURSOR_RULES_DIR = path.join(CURSOR_DIR, "rules");
+const CURSOR_RULES_PATH = path.join(CURSOR_RULES_DIR, "codiedev.mdc");
+// GUI-launched agents (Cursor.app, future JetBrains plugins) don't source the
+// user's shell rc, so nvm-managed `npx` and `node` aren't on PATH. Resolve the
+// absolute path to the current node binary and our hook.js at install time and
+// write that into hook configs so execution doesn't depend on the spawned
+// shell's PATH. Falls back to `npx` if we can't resolve dist/hook.js.
+function shellQuote(s) {
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function resolveHookCommand(subcommand) {
+    try {
+        const cliEntry = process.argv[1];
+        if (cliEntry) {
+            const realCli = fs.realpathSync(cliEntry);
+            const distDir = path.dirname(realCli);
+            const hookScript = path.join(distDir, "hook.js");
+            if (fs.existsSync(hookScript)) {
+                return `${shellQuote(process.execPath)} ${shellQuote(hookScript)} ${subcommand}`;
+            }
+        }
+    }
+    catch {
+        // Fall through to npx fallback.
+    }
+    return `npx codiedev-hook ${subcommand}`;
+}
+function isCodiedevHookCommand(cmd) {
+    if (!cmd)
+        return false;
+    return cmd.includes("codiedev-hook") || /codiedev[\\/]dist[\\/]hook/.test(cmd);
+}
 function claudeCodeInstalled() {
     return fs.existsSync(CLAUDE_DIR);
 }
 function codexInstalled() {
     return fs.existsSync(CODEX_DIR);
 }
+function cursorInstalled() {
+    return fs.existsSync(CURSOR_DIR);
+}
 function installHook() {
     let settings = {};
     try {
@@ -157,30 +199,27 @@ function installHook() {
     if (!hooks.SessionEnd) {
         hooks.SessionEnd = [];
     }
-    const sessionEndHooks = hooks.SessionEnd;
-    const alreadyInstalled = sessionEndHooks.some((hook) => {
-        const matcher = hook.matcher;
-        const hooks2 = hook.hooks;
-        if (hooks2) {
-            return hooks2.some((h) => {
-                const cmd = h.command;
-                return cmd && cmd.includes("codiedev-hook");
-            });
+    // Drop any prior codiedev entries (legacy `npx` form or older absolute
+    // paths) before re-adding so connect re-runs upgrade the resolved binary
+    // path instead of leaving stale entries behind.
+    const existing = hooks.SessionEnd;
+    const filtered = existing.filter((hook) => {
+        const inner = hook.hooks;
+        if (Array.isArray(inner)) {
+            return !inner.some((h) => isCodiedevHookCommand(h.command));
         }
-        return matcher && matcher.includes("codiedev-hook");
+        return !isCodiedevHookCommand(hook.matcher);
     });
-    if (alreadyInstalled) {
-        return;
-    }
-    sessionEndHooks.push({
+    filtered.push({
         matcher: ".*",
         hooks: [
             {
                 type: "command",
-                command: "npx codiedev-hook capture",
+                command: resolveHookCommand("capture"),
             },
         ],
     });
+    hooks.SessionEnd = filtered;
     if (!fs.existsSync(CLAUDE_DIR)) {
         fs.mkdirSync(CLAUDE_DIR, { recursive: true });
     }
@@ -312,25 +351,74 @@ function installClaudeCodeInstructions() {
 function installCodexInstructions() {
     writeInstructionsBlock(CODEX_USER_INSTRUCTIONS_PATH);
 }
+// Cursor uses .mdc rule files with YAML frontmatter (description, alwaysApply,
+// globs). `.cursorrules` is deprecated and ignored by Agent mode as of 2026.
+const CURSOR_INSTRUCTIONS_FRONTMATTER = `---
+description: CodieDev team artifact layer — push, pull, search, ping, and share artifacts with teammates
+alwaysApply: true
+---
+
+`;
+function installCursorInstructions() {
+    if (!fs.existsSync(CURSOR_RULES_DIR)) {
+        fs.mkdirSync(CURSOR_RULES_DIR, { recursive: true });
+    }
+    const block = CURSOR_INSTRUCTIONS_FRONTMATTER +
+        CODIEDEV_INSTRUCTIONS_BEGIN +
+        "\n" +
+        CODIEDEV_INSTRUCTIONS_BODY +
+        "\n" +
+        CODIEDEV_INSTRUCTIONS_END +
+        "\n";
+    let existing = "";
+    if (fs.existsSync(CURSOR_RULES_PATH)) {
+        existing = fs.readFileSync(CURSOR_RULES_PATH, "utf8");
+    }
+    // If the file already has our markers, replace just the block — preserve
+    // any frontmatter edits the user made.
+    const beginIdx = existing.indexOf(CODIEDEV_INSTRUCTIONS_BEGIN);
+    const endIdx = existing.indexOf(CODIEDEV_INSTRUCTIONS_END);
+    let next;
+    if (beginIdx !== -1 && endIdx !== -1 && endIdx > beginIdx) {
+        next =
+            existing.slice(0, beginIdx) +
+                CODIEDEV_INSTRUCTIONS_BEGIN +
+                "\n" +
+                CODIEDEV_INSTRUCTIONS_BODY +
+                "\n" +
+                CODIEDEV_INSTRUCTIONS_END +
+                existing.slice(endIdx + CODIEDEV_INSTRUCTIONS_END.length);
+    }
+    else {
+        next = block;
+    }
+    fs.writeFileSync(CURSOR_RULES_PATH, next, "utf8");
+}
+function readMcpConfigSafely(path) {
+    if (!fs.existsSync(path))
+        return {};
+    const raw = fs.readFileSync(path, "utf8");
+    if (!raw.trim())
+        return {};
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        const backup = `${path}.bak.${Date.now()}`;
+        fs.copyFileSync(path, backup);
+        console.warn(`Warning: ${path} contained invalid JSON. Backed up to ${backup} before rewriting.`);
+        return {};
+    }
+}
 /**
  * Install the CodieDev MCP server into Claude Code's user-scope config.
  * Safe to call multiple times — updates the existing entry if present.
  */
 function installClaudeCodeMcp() {
-    let config = {};
-    try {
-        if (fs.existsSync(CLAUDE_USER_CONFIG_PATH)) {
-            const raw = fs.readFileSync(CLAUDE_USER_CONFIG_PATH, "utf8");
-            config = raw.trim() ? JSON.parse(raw) : {};
-        }
-    }
-    catch {
-        // Start fresh if the existing file is corrupt — safer than failing the install.
-        config = {};
-    }
+    const config = readMcpConfigSafely(CLAUDE_USER_CONFIG_PATH);
     const mcpServers = config.mcpServers ?? {};
-    // Canonical Claude Code user-scope format: just command + args.
-    // No `type` field (some CC versions reject it; stdio is the default).
+    if (mcpServers.codiedev)
+        return;
     mcpServers.codiedev = {
         command: "npx",
         args: ["codiedev-mcp"],
@@ -338,6 +426,27 @@ function installClaudeCodeMcp() {
     config.mcpServers = mcpServers;
     fs.writeFileSync(CLAUDE_USER_CONFIG_PATH, JSON.stringify(config, null, 2), "utf8");
 }
+/**
+ * Install the CodieDev MCP server into Cursor's user-scope config.
+ * Cursor uses the same `mcpServers` schema as Claude Code; just a different
+ * file path (~/.cursor/mcp.json). Project-scoped servers can also live at
+ * <project>/.cursor/mcp.json — we only manage the user-scope one.
+ */
+function installCursorMcp() {
+    if (!fs.existsSync(CURSOR_DIR)) {
+        fs.mkdirSync(CURSOR_DIR, { recursive: true });
+    }
+    const config = readMcpConfigSafely(CURSOR_MCP_PATH);
+    const mcpServers = config.mcpServers ?? {};
+    if (mcpServers.codiedev)
+        return;
+    mcpServers.codiedev = {
+        command: "npx",
+        args: ["codiedev-mcp"],
+    };
+    config.mcpServers = mcpServers;
+    fs.writeFileSync(CURSOR_MCP_PATH, JSON.stringify(config, null, 2), "utf8");
+}
 /**
  * Best-effort append of the CodieDev MCP server block to ~/.codex/config.toml.
  *
@@ -387,33 +496,66 @@ function installCodexHook() {
     if (!hooks.Stop) {
         hooks.Stop = [];
     }
-    const stopHooks = hooks.Stop;
-    const alreadyInstalled = stopHooks.some((hook) => {
+    const existing = hooks.Stop;
+    const filtered = existing.filter((hook) => {
         const inner = hook.hooks;
-        if (!inner)
-            return false;
-        return inner.some((h) => {
-            const cmd = h.command;
-            return cmd && cmd.includes("codiedev-hook");
-        });
+        if (!Array.isArray(inner))
+            return true;
+        return !inner.some((h) => isCodiedevHookCommand(h.command));
     });
-    if (alreadyInstalled) {
-        return;
-    }
-    stopHooks.push({
+    filtered.push({
         hooks: [
             {
                 type: "command",
-                command: "npx codiedev-hook capture-codex",
+                command: resolveHookCommand("capture-codex"),
                 timeout: 30,
             },
         ],
     });
+    hooks.Stop = filtered;
     if (!fs.existsSync(CODEX_DIR)) {
         fs.mkdirSync(CODEX_DIR, { recursive: true });
     }
     fs.writeFileSync(CODEX_HOOKS_PATH, JSON.stringify(hooksFile, null, 2), "utf8");
 }
+// Cursor's hooks.json uses { version: 1, hooks: { sessionEnd: [{ command, type, timeout }] } }.
+// `sessionEnd` fires when a conversation closes (completed, aborted, error,
+// window_close, user_close); the base stdin payload includes transcript_path
+// and session_id which `codiedev-hook capture-cursor` reads to upload.
+function installCursorHook() {
+    if (!fs.existsSync(CURSOR_DIR)) {
+        fs.mkdirSync(CURSOR_DIR, { recursive: true });
+    }
+    let hooksFile = {};
+    try {
+        if (fs.existsSync(CURSOR_HOOKS_PATH)) {
+            const raw = fs.readFileSync(CURSOR_HOOKS_PATH, "utf8");
+            hooksFile = raw.trim() ? JSON.parse(raw) : {};
+        }
+    }
+    catch {
+        hooksFile = {};
+    }
+    if (!hooksFile.version) {
+        hooksFile.version = 1;
+    }
+    if (!hooksFile.hooks) {
+        hooksFile.hooks = {};
+    }
+    const hooks = hooksFile.hooks;
+    if (!hooks.sessionEnd) {
+        hooks.sessionEnd = [];
+    }
+    const existing = hooks.sessionEnd;
+    const filtered = existing.filter((h) => !isCodiedevHookCommand(h.command));
+    filtered.push({
+        command: resolveHookCommand("capture-cursor"),
+        type: "command",
+        timeout: 30,
+    });
+    hooks.sessionEnd = filtered;
+    fs.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(hooksFile, null, 2), "utf8");
+}
 function parseClaudeCodeStats(content) {
     let messageCount = 0;
     let toolCallCount = 0;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "codiedev",
-  "version": "0.5.6",
-  "description": "Connect Claude Code or Codex to CodieDev for org-wide session capture and artifact collaboration",
+  "version": "0.6.1",
+  "description": "Connect Claude Code, Codex, or Cursor to CodieDev for org-wide session capture and artifact collaboration",
   "bin": {
     "codiedev": "./dist/cli.js",
     "codiedev-hook": "./dist/hook.js"
@@ -21,6 +21,7 @@
     "claude",
     "codex",
     "openai",
+    "cursor",
     "ai",
     "session-capture"
   ],