codiedev 0.1.0 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # codiedev
 
-Connect Claude Code to CodieDev for org-wide session capture.
+Connect Claude Code or Codex to CodieDev for org-wide session capture.
 
 ## Usage
 
@@ -8,7 +8,12 @@ Connect Claude Code to CodieDev for org-wide session capture.
 npx codiedev connect
 ```
 
-The CLI will prompt you for an API token (get one at https://codiedev.com/portal/integrations/claude-code), then install a Claude Code `SessionEnd` hook that uploads transcripts from your tracked repos to your CodieDev workspace.
+The CLI will prompt you for an API token (get one at https://codiedev.com/portal/integrations/claude-code), then install a capture hook into whichever agent CLIs are present on your machine:
+
+- **Claude Code** — `SessionEnd` hook in `~/.claude/settings.json`
+- **Codex** — `Stop` hook in `~/.codex/hooks.json`
+
+If both are installed, hooks are wired up for both. If neither is installed, the config is saved and you can re-run `connect` after installing one.
 
 ## What gets captured
 
@@ -16,8 +21,12 @@ The CLI will prompt you for an API token (get one at https://codiedev.com/portal
 - Transcript + basic stats (message count, tool calls)
 - Processed into summaries and embeddings server-side for search in `/portal/memories`
 
-## Config
+Each captured memory records its `source` (`claude-code` or `codex`) so you can filter in the portal.
 
-Written to `~/.codiedev/config.json`. The `SessionEnd` hook is added to `~/.claude/settings.json`.
+## Codex note
+
+Codex doesn't currently expose a `SessionEnd` event, so the hook runs on `Stop` (fires after each assistant turn). The backend dedupes by `(company, session_id)` and replaces the stored transcript on re-upload so the latest turn's snapshot wins. Summarization happens once per session; subsequent turn uploads keep the raw transcript fresh but don't re-summarize (to avoid running up LLM cost).
+
+## Config
 
-Override the backend with `CODIEDEV_URL` if needed.
+Written to `~/.codiedev/config.json`. Override the backend with `CODIEDEV_URL` if needed.

package/dist/connect.js

@@ -139,17 +139,43 @@ async function main() {
         console.error(`\nError: Failed to save config — ${err.message}`);
         process.exit(1);
     }
-    try {
-        (0, utils_1.installHook)();
+    const hasClaude = (0, utils_1.claudeCodeInstalled)();
+    const hasCodex = (0, utils_1.codexInstalled)();
+    const installed = [];
+    if (hasClaude) {
+        try {
+            (0, utils_1.installHook)();
+            installed.push("Claude Code (SessionEnd → ~/.claude/settings.json)");
+        }
+        catch (err) {
+            console.error(`\nWarning: Failed to install Claude Code hook — ${err.message}`);
+        }
     }
-    catch (err) {
-        console.error(`\nWarning: Failed to install SessionEnd hook — ${err.message}`);
-        console.error("You can install it manually by adding npx codiedev-hook capture to your ~/.claude/settings.json hooks.");
-        // Don't exit — config was saved successfully
+    if (hasCodex) {
+        try {
+            (0, utils_1.installCodexHook)();
+            installed.push("Codex (Stop → ~/.codex/hooks.json)");
+        }
+        catch (err) {
+            console.error(`\nWarning: Failed to install Codex hook — ${err.message}`);
+        }
+    }
+    if (!hasClaude && !hasCodex) {
+        console.warn("\nNo Claude Code (~/.claude) or Codex (~/.codex) install detected.");
+        console.warn("Config saved. Install one, then re-run `npx codiedev connect` to wire up capture hooks.");
     }
     console.log(`\nConnected to ${companyName}`);
     console.log(`Tracking ${repos.length} repo${repos.length === 1 ? "" : "s"}`);
-    console.log("SessionEnd hook installed — sessions will be captured automatically.\n");
+    if (installed.length > 0) {
+        console.log("Installed capture hook(s):");
+        for (const target of installed) {
+            console.log(`  - ${target}`);
+        }
+        console.log("Sessions will be captured automatically.\n");
+    }
+    else {
+        console.log();
+    }
 }
 main().catch((err) => {
     console.error("Unexpected error:", err);

package/dist/hook.js

@@ -73,41 +73,6 @@ function postJson(url, body, bearerToken) {
         req.end();
     });
 }
-function parseTranscriptStats(transcriptPath) {
-    let messageCount = 0;
-    let toolCallCount = 0;
-    try {
-        const content = fs.readFileSync(transcriptPath, "utf8");
-        const lines = content.split("\n").filter((l) => l.trim());
-        for (const line of lines) {
-            try {
-                const entry = JSON.parse(line);
-                if (!entry || typeof entry !== "object")
-                    continue;
-                // Claude Code transcript entries have type: "user" or "assistant" for messages
-                if (entry.type === "user" || entry.type === "assistant") {
-                    messageCount++;
-                }
-                // Tool calls live in the message.content array as blocks with type "tool_use"
-                const content = entry.message?.content;
-                if (Array.isArray(content)) {
-                    for (const block of content) {
-                        if (block && block.type === "tool_use") {
-                            toolCallCount++;
-                        }
-                    }
-                }
-            }
-            catch {
-                // Skip malformed lines
-            }
-        }
-    }
-    catch {
-        // If we can't read/parse, return zeros
-    }
-    return { messageCount, toolCallCount };
-}
 async function readStdin() {
     return new Promise((resolve, reject) => {
         let data = "";
@@ -119,8 +84,13 @@ async function readStdin() {
         process.stdin.on("error", reject);
     });
 }
+function resolveMode(arg) {
+    if (arg === "capture-codex")
+        return "codex";
+    return "claude-code";
+}
 async function main() {
-    // Read hook input from stdin
+    const mode = resolveMode(process.argv[2]);
     let hookInput = {};
     try {
         const raw = await readStdin();
@@ -129,67 +99,61 @@ async function main() {
         }
     }
     catch {
-        // If stdin is malformed, exit silently
         process.exit(0);
     }
     const { session_id, transcript_path, cwd } = hookInput;
-    // Read config — if missing, exit silently
     const config = (0, utils_1.readConfig)();
     if (!config) {
         process.exit(0);
     }
-    // Determine working directory
-    const workingDir = cwd || process.cwd();
-    // Get git remote URL for this directory
-    const remoteUrl = (0, utils_1.getGitRemoteUrl)(workingDir);
-    if (!remoteUrl) {
-        // Not a git repo or no remote — exit silently
-        process.exit(0);
-    }
-    // Check if this repo is in our tracked repos
-    const matchedRepo = (0, utils_1.matchRepo)(remoteUrl, config.repos);
-    if (!matchedRepo) {
-        // Repo not tracked — exit silently
-        process.exit(0);
-    }
-    // Validate transcript path
     if (!transcript_path) {
         process.exit(0);
     }
-    // Read transcript file
     let transcriptContent;
     try {
         transcriptContent = fs.readFileSync(transcript_path, "utf8");
     }
     catch {
-        // Can't read transcript — exit silently
         process.exit(0);
     }
-    // Parse transcript stats
-    const { messageCount, toolCallCount } = parseTranscriptStats(transcript_path);
-    // Base64 encode transcript
+    // Resolve repo URL. Codex embeds it in session_meta; fall back to git for CC.
+    let remoteUrl = null;
+    if (mode === "codex") {
+        remoteUrl = (0, utils_1.extractCodexRepoUrl)(transcriptContent);
+    }
+    if (!remoteUrl) {
+        remoteUrl = (0, utils_1.getGitRemoteUrl)(cwd || process.cwd());
+    }
+    if (!remoteUrl) {
+        process.exit(0);
+    }
+    const matchedRepo = (0, utils_1.matchRepo)(remoteUrl, config.repos);
+    if (!matchedRepo) {
+        process.exit(0);
+    }
+    const stats = mode === "codex"
+        ? (0, utils_1.parseCodexStats)(transcriptContent)
+        : (0, utils_1.parseClaudeCodeStats)(transcriptContent);
     const transcriptBase64 = Buffer.from(transcriptContent, "utf8").toString("base64");
-    // POST to backend
     const payload = {
         sessionId: session_id,
         repoUrl: remoteUrl,
         repoId: matchedRepo.repoId,
         companyId: config.companyId,
         transcript: transcriptBase64,
-        messageCount,
-        toolCallCount,
+        messageCount: stats.messageCount,
+        toolCallCount: stats.toolCallCount,
         capturedAt: Date.now(),
+        source: mode,
     };
     try {
         await postJson(`${config.backendUrl}/api/captureSession`, payload, config.token);
     }
     catch (err) {
-        // Write warning to stderr, but exit 0 — never block Claude Code
         process.stderr.write(`[codiedev-hook] Warning: Failed to capture session — ${err.message}\n`);
     }
     process.exit(0);
 }
 main().catch(() => {
-    // Never block Claude Code on any error
     process.exit(0);
 });

package/dist/utils.d.ts

@@ -24,4 +24,14 @@ export declare function matchRepo(remoteUrl: string, repos: Array<{
     fullName: string;
 } | null;
 export declare function hashToken(token: string): string;
+export declare function claudeCodeInstalled(): boolean;
+export declare function codexInstalled(): boolean;
 export declare function installHook(): void;
+export declare function installCodexHook(): void;
+export interface ParsedStats {
+    messageCount: number;
+    toolCallCount: number;
+}
+export declare function parseClaudeCodeStats(content: string): ParsedStats;
+export declare function parseCodexStats(content: string): ParsedStats;
+export declare function extractCodexRepoUrl(content: string): string | null;

package/dist/utils.js

@@ -39,7 +39,13 @@ exports.getGitRemoteUrl = getGitRemoteUrl;
 exports.normalizeRepoUrl = normalizeRepoUrl;
 exports.matchRepo = matchRepo;
 exports.hashToken = hashToken;
+exports.claudeCodeInstalled = claudeCodeInstalled;
+exports.codexInstalled = codexInstalled;
 exports.installHook = installHook;
+exports.installCodexHook = installCodexHook;
+exports.parseClaudeCodeStats = parseClaudeCodeStats;
+exports.parseCodexStats = parseCodexStats;
+exports.extractCodexRepoUrl = extractCodexRepoUrl;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
@@ -120,6 +126,15 @@ function hashToken(token) {
     return hash.toString(36);
 }
 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");
+function claudeCodeInstalled() {
+    return fs.existsSync(CLAUDE_DIR);
+}
+function codexInstalled() {
+    return fs.existsSync(CODEX_DIR);
+}
 function installHook() {
     let settings = {};
     try {
@@ -131,17 +146,14 @@ function installHook() {
     catch {
         // Start with empty settings if file doesn't exist or is invalid
     }
-    // Ensure hooks object exists
     if (!settings.hooks) {
         settings.hooks = {};
     }
     const hooks = settings.hooks;
-    // Ensure SessionEnd array exists
     if (!hooks.SessionEnd) {
         hooks.SessionEnd = [];
     }
     const sessionEndHooks = hooks.SessionEnd;
-    // Check if codiedev-hook is already installed
     const alreadyInstalled = sessionEndHooks.some((hook) => {
         const matcher = hook.matcher;
         const hooks2 = hook.hooks;
@@ -156,7 +168,6 @@ function installHook() {
     if (alreadyInstalled) {
         return;
     }
-    // Add the codiedev-hook capture entry
     sessionEndHooks.push({
         matcher: ".*",
         hooks: [
@@ -166,10 +177,137 @@ function installHook() {
             },
         ],
     });
-    // Ensure directory exists
-    const settingsDir = path.dirname(CLAUDE_SETTINGS_PATH);
-    if (!fs.existsSync(settingsDir)) {
-        fs.mkdirSync(settingsDir, { recursive: true });
+    if (!fs.existsSync(CLAUDE_DIR)) {
+        fs.mkdirSync(CLAUDE_DIR, { recursive: true });
     }
     fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf8");
 }
+// Codex doesn't have a SessionEnd event yet — Stop fires after every turn.
+// The backend dedupes on (companyId, sessionId) and replaces the stored
+// transcript on re-upload, so the latest turn's snapshot wins.
+function installCodexHook() {
+    let hooksFile = {};
+    try {
+        if (fs.existsSync(CODEX_HOOKS_PATH)) {
+            const raw = fs.readFileSync(CODEX_HOOKS_PATH, "utf8");
+            hooksFile = JSON.parse(raw);
+        }
+    }
+    catch {
+        // Start fresh if missing or invalid
+    }
+    if (!hooksFile.hooks) {
+        hooksFile.hooks = {};
+    }
+    const hooks = hooksFile.hooks;
+    if (!hooks.Stop) {
+        hooks.Stop = [];
+    }
+    const stopHooks = hooks.Stop;
+    const alreadyInstalled = stopHooks.some((hook) => {
+        const inner = hook.hooks;
+        if (!inner)
+            return false;
+        return inner.some((h) => {
+            const cmd = h.command;
+            return cmd && cmd.includes("codiedev-hook");
+        });
+    });
+    if (alreadyInstalled) {
+        return;
+    }
+    stopHooks.push({
+        hooks: [
+            {
+                type: "command",
+                command: "npx codiedev-hook capture-codex",
+                timeout: 30,
+            },
+        ],
+    });
+    if (!fs.existsSync(CODEX_DIR)) {
+        fs.mkdirSync(CODEX_DIR, { recursive: true });
+    }
+    fs.writeFileSync(CODEX_HOOKS_PATH, JSON.stringify(hooksFile, null, 2), "utf8");
+}
+function parseClaudeCodeStats(content) {
+    let messageCount = 0;
+    let toolCallCount = 0;
+    const lines = content.split("\n").filter((l) => l.trim());
+    for (const line of lines) {
+        try {
+            const entry = JSON.parse(line);
+            if (!entry || typeof entry !== "object")
+                continue;
+            if (entry.type === "user" || entry.type === "assistant") {
+                messageCount++;
+            }
+            const c = entry.message?.content;
+            if (Array.isArray(c)) {
+                for (const block of c) {
+                    if (block && block.type === "tool_use")
+                        toolCallCount++;
+                }
+            }
+        }
+        catch {
+            // Skip malformed lines
+        }
+    }
+    return { messageCount, toolCallCount };
+}
+// Codex session JSONL format (rollout-*.jsonl):
+//   {type:"session_meta", payload:{id, cwd, git:{repository_url,...}, ...}}
+//   {type:"response_item", payload:{type:"message", role, content:[{type:"input_text",text}|{type:"output_text",text}]}}
+//   {type:"response_item", payload:{type:"function_call", name, arguments, call_id}}
+//   {type:"response_item", payload:{type:"function_call_output", call_id, output}}
+//   {type:"event_msg", payload:{type:"token_count"|"agent_reasoning"|...}}
+//   {type:"turn_context", payload:{cwd, model, ...}}
+function parseCodexStats(content) {
+    let messageCount = 0;
+    let toolCallCount = 0;
+    const lines = content.split("\n").filter((l) => l.trim());
+    for (const line of lines) {
+        try {
+            const entry = JSON.parse(line);
+            if (!entry || typeof entry !== "object")
+                continue;
+            if (entry.type !== "response_item")
+                continue;
+            const payloadType = entry.payload?.type;
+            if (payloadType === "message") {
+                messageCount++;
+            }
+            else if (payloadType === "function_call") {
+                toolCallCount++;
+            }
+        }
+        catch {
+            // Skip malformed lines
+        }
+    }
+    return { messageCount, toolCallCount };
+}
+// Pull repository URL from the Codex transcript's session_meta line so we
+// don't depend on the hook's cwd being a git repo.
+function extractCodexRepoUrl(content) {
+    const lines = content.split("\n");
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const entry = JSON.parse(trimmed);
+            if (entry?.type === "session_meta") {
+                const url = entry.payload?.git?.repository_url;
+                if (typeof url === "string" && url.length > 0)
+                    return url;
+                return null; // session_meta is first — no point scanning further
+            }
+        }
+        catch {
+            // Keep scanning
+        }
+    }
+    return null;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "codiedev",
-  "version": "0.1.0",
-  "description": "Connect Claude Code to CodieDev for org-wide session capture",
+  "version": "0.2.0",
+  "description": "Connect Claude Code or Codex to CodieDev for org-wide session capture",
   "bin": {
     "codiedev": "./dist/connect.js",
     "codiedev-hook": "./dist/hook.js"
@@ -16,6 +16,8 @@
     "codiedev",
     "claude-code",
     "claude",
+    "codex",
+    "openai",
     "ai",
     "session-capture"
   ],