codiedev 0.9.14 → 0.9.16-beta.0

package/dist/hook.js

@@ -41,6 +41,7 @@ const https = __importStar(require("https"));
 const http = __importStar(require("http"));
 const child_process_1 = require("child_process");
 const utils_1 = require("./utils");
+const limitEvent_1 = require("./limitEvent");
 const version_1 = require("./version");
 function getJson(url, bearerToken) {
     return new Promise((resolve, reject) => {
@@ -103,6 +104,61 @@ async function runDiscover(prompt) {
     }
     process.exit(0);
 }
+// StopFailure (matcher rate_limit): the dev just got blocked. Read the local
+// transcript tail for the ground-truth rate_limit line and POST a tiny event.
+// Best-effort + silent — StopFailure output is ignored by Claude Code anyway.
+async function runStopFailure(hookInput) {
+    const config = (0, utils_1.readConfig)();
+    if (!config)
+        process.exit(0);
+    let event = null;
+    const tp = hookInput.transcript_path;
+    if (tp) {
+        try {
+            event = (0, limitEvent_1.parseLimitEventFromTranscript)(fs.readFileSync(tp, "utf8"));
+        }
+        catch {
+            /* unreadable transcript — fall through to minimal event */
+        }
+    }
+    // The hook is registered with matcher "rate_limit", so a miss still means a
+    // real limit — emit a minimal event rather than dropping it.
+    const payload = event ?? { kind: "other", at: Date.now(), resetText: null };
+    try {
+        await postJson(`${config.backendUrl}/api/cli/limitEvent`, {
+            kind: payload.kind,
+            at: payload.at,
+            resetText: payload.resetText,
+            sessionId: hookInput.session_id,
+        }, config.token);
+    }
+    catch {
+        /* best-effort */
+    }
+    process.exit(0);
+}
+// SessionStart: the capture-coverage denominator. Record that a session opened
+// so the backend can later compute captured ÷ started. Deliberately tiny — no
+// transcript read, no git — so it never slows session startup. Best-effort +
+// silent (SessionStart hook output is ignored by Claude Code).
+async function runSessionStart(hookInput) {
+    const config = (0, utils_1.readConfig)();
+    if (!config)
+        process.exit(0);
+    if (hookInput.session_id) {
+        try {
+            await postJson(`${config.backendUrl}/api/cli/sessionStart`, {
+                sessionId: hookInput.session_id,
+                startedAt: Date.now(),
+                source: "claude-code",
+            }, config.token);
+        }
+        catch {
+            /* best-effort — never block session startup */
+        }
+    }
+    process.exit(0);
+}
 function postJson(url, body, bearerToken) {
     return new Promise((resolve, reject) => {
         const parsed = new URL(url);
@@ -229,12 +285,24 @@ async function main() {
         await runDiscover(hookInput.prompt);
         return;
     }
+    // StopFailure (matcher rate_limit): post the rate-limit event.
+    if (process.argv[2] === "limit") {
+        await runStopFailure(hookInput);
+        return;
+    }
+    // SessionStart: post the capture-coverage denominator ping. Tiny + fast.
+    if (process.argv[2] === "session-start") {
+        await runSessionStart(hookInput);
+        return;
+    }
     // Self-heal: a user who upgraded the CLI but hasn't re-run `connect` gets the
-    // discovery + auto-backup hooks wired on their next SessionEnd, without
+    // discovery + auto-backup + limit hooks wired on their next SessionEnd, without
     // re-connecting. Cheap (settings.json read, writes only when missing), so it
     // stays inline; the costly transcript/git work is what moves to the child.
     (0, utils_1.ensureDiscoveryHookInstalled)();
     (0, utils_1.ensureBackupHookInstalled)();
+    (0, utils_1.ensureLimitHookInstalled)();
+    (0, utils_1.ensureSessionStartHookInstalled)();
     const { session_id, transcript_path, cwd, workspace_roots } = hookInput;
     const workspaceRoot = workspace_roots && workspace_roots.length > 0
         ? workspace_roots[0]

package/dist/limitEvent.d.ts

@@ -0,0 +1,8 @@
+export type LimitKind = "session" | "org_spend" | "other";
+export interface LimitEvent {
+    kind: LimitKind;
+    at: number;
+    resetText: string | null;
+}
+export declare function classifyLimitKind(text: string): LimitKind;
+export declare function parseLimitEventFromTranscript(transcript: string): LimitEvent | null;

package/dist/limitEvent.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyLimitKind = classifyLimitKind;
+exports.parseLimitEventFromTranscript = parseLimitEventFromTranscript;
+function classifyLimitKind(text) {
+    const t = text.toLowerCase();
+    if (t.includes("session limit"))
+        return "session";
+    if (t.includes("spend limit") || t.includes("monthly spend"))
+        return "org_spend";
+    return "other";
+}
+// "… · resets 9:50pm (UTC)" → "9:50pm (UTC)". Null when absent.
+function parseResetText(text) {
+    const m = text.match(/resets\s+(.+?)\s*$/i);
+    return m ? m[1].trim() : null;
+}
+function messageText(entry) {
+    const c = entry?.message?.content;
+    if (typeof c === "string")
+        return c;
+    if (Array.isArray(c))
+        return c.map((x) => (x && typeof x === "object" ? x.text ?? "" : "")).join(" ");
+    return "";
+}
+// Scans transcript JSONL for the LAST top-level `error: "rate_limit"` entry.
+// (Validated shape: error/isApiErrorMessage are top-level, not under message.)
+function parseLimitEventFromTranscript(transcript) {
+    let found = null;
+    for (const line of transcript.split("\n")) {
+        if (!line.includes('"rate_limit"'))
+            continue;
+        let e;
+        try {
+            e = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (e?.error !== "rate_limit" && !e?.isApiErrorMessage)
+            continue;
+        const text = messageText(e);
+        const at = e?.timestamp ? Date.parse(e.timestamp) : NaN;
+        found = {
+            kind: classifyLimitKind(text),
+            at: Number.isNaN(at) ? Date.now() : at,
+            resetText: parseResetText(text),
+        };
+    }
+    return found;
+}

package/dist/utils.d.ts

@@ -73,10 +73,12 @@ export declare function cursorInstalled(): boolean;
  * the presence of any `github.copilot*` directory as the Copilot fingerprint.
  */
 export declare function vscodeCopilotInstalled(): boolean;
-export declare function upsertCodiedevHook(hooks: Record<string, unknown>, eventName: string, subcommand: string): void;
+export declare function upsertCodiedevHook(hooks: Record<string, unknown>, eventName: string, subcommand: string, matcher?: string): void;
 export declare function installHook(): void;
 export declare function ensureDiscoveryHookInstalled(): void;
 export declare function ensureBackupHookInstalled(): void;
+export declare function ensureLimitHookInstalled(): void;
+export declare function ensureSessionStartHookInstalled(): void;
 export declare function installClaudeCodeInstructions(): void;
 export declare function installCodexInstructions(): void;
 export declare function installCursorInstructions(): void;

package/dist/utils.js

@@ -59,6 +59,8 @@ exports.upsertCodiedevHook = upsertCodiedevHook;
 exports.installHook = installHook;
 exports.ensureDiscoveryHookInstalled = ensureDiscoveryHookInstalled;
 exports.ensureBackupHookInstalled = ensureBackupHookInstalled;
+exports.ensureLimitHookInstalled = ensureLimitHookInstalled;
+exports.ensureSessionStartHookInstalled = ensureSessionStartHookInstalled;
 exports.installClaudeCodeInstructions = installClaudeCodeInstructions;
 exports.installCodexInstructions = installCodexInstructions;
 exports.installCursorInstructions = installCursorInstructions;
@@ -760,7 +762,7 @@ function vscodeCopilotInstalled() {
 // with `subcommand`) into the given hook event, stripping any prior codiedev
 // entries first so connect re-runs / upgrades refresh the resolved binary path.
 // Mutates `hooks` in place. Exported for unit testing.
-function upsertCodiedevHook(hooks, eventName, subcommand) {
+function upsertCodiedevHook(hooks, eventName, subcommand, matcher = ".*") {
     if (!hooks[eventName])
         hooks[eventName] = [];
     const existing = hooks[eventName];
@@ -772,7 +774,7 @@ function upsertCodiedevHook(hooks, eventName, subcommand) {
         return !(0, detection_1.isCodiedevHookCommand)(hook.matcher);
     });
     filtered.push({
-        matcher: ".*",
+        matcher,
         hooks: [{ type: "command", command: resolveHookCommand(subcommand) }],
     });
     hooks[eventName] = filtered;
@@ -798,6 +800,11 @@ function installHook() {
     upsertCodiedevHook(hooks, "UserPromptSubmit", "discover");
     // Stop → backup (auto-back-up changed artifact files to your private library).
     upsertCodiedevHook(hooks, "Stop", "backup");
+    // StopFailure (matcher rate_limit) → limit (post rate-limit event to the team).
+    upsertCodiedevHook(hooks, "StopFailure", "limit", "rate_limit");
+    // SessionStart → session-start (capture-coverage denominator: record that a
+    // session opened, independent of whether it later captures).
+    upsertCodiedevHook(hooks, "SessionStart", "session-start");
     if (!fs.existsSync(CLAUDE_DIR)) {
         fs.mkdirSync(CLAUDE_DIR, { recursive: true });
     }
@@ -853,6 +860,52 @@ function ensureBackupHookInstalled() {
     }
     catch { /* best-effort */ }
 }
+// Self-heal: ensure the StopFailure (matcher rate_limit) → limit hook is
+// present without a full `connect` re-run, mirroring ensureBackupHookInstalled.
+// Called from the capture hook so an upgraded-but-not-reconnected user gets the
+// limit-event hook wired on their next session. Only writes when missing.
+function ensureLimitHookInstalled() {
+    try {
+        if (!fs.existsSync(CLAUDE_SETTINGS_PATH))
+            return;
+        const settings = JSON.parse(fs.readFileSync(CLAUDE_SETTINGS_PATH, "utf8"));
+        const hooks = (settings.hooks ?? {});
+        const sf = (hooks.StopFailure ?? []);
+        const present = sf.some((h) => {
+            const inner = h.hooks;
+            return Array.isArray(inner) && inner.some((x) => (0, detection_1.isCodiedevHookCommand)(x.command));
+        });
+        if (present)
+            return;
+        settings.hooks = hooks;
+        upsertCodiedevHook(hooks, "StopFailure", "limit", "rate_limit");
+        fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf8");
+    }
+    catch { /* best-effort */ }
+}
+// Self-heal: ensure the SessionStart → session-start hook is present without a
+// full `connect` re-run, mirroring ensureLimitHookInstalled. Called from the
+// capture hook so an upgraded-but-not-reconnected user starts emitting the
+// capture-coverage denominator on their next session. Only writes when missing.
+function ensureSessionStartHookInstalled() {
+    try {
+        if (!fs.existsSync(CLAUDE_SETTINGS_PATH))
+            return;
+        const settings = JSON.parse(fs.readFileSync(CLAUDE_SETTINGS_PATH, "utf8"));
+        const hooks = (settings.hooks ?? {});
+        const ss = (hooks.SessionStart ?? []);
+        const present = ss.some((h) => {
+            const inner = h.hooks;
+            return Array.isArray(inner) && inner.some((x) => (0, detection_1.isCodiedevHookCommand)(x.command));
+        });
+        if (present)
+            return;
+        settings.hooks = hooks;
+        upsertCodiedevHook(hooks, "SessionStart", "session-start");
+        fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf8");
+    }
+    catch { /* best-effort */ }
+}
 // ─────────────────────────────────────────────────────────────────────────────
 // MCP server installation — writes the codiedev MCP server config into each
 // agent CLI's expected location so "npx codiedev connect" wires it up once.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.14",
+  "version": "0.9.16-beta.0",
   "description": "Connect Claude Code, Codex, Cursor, or VS Code Copilot to Codiedev for org-wide session capture and artifact collaboration",
   "bin": {
     "codiedev": "dist/cli.js",