codiedev 0.9.83 → 0.9.85

package/dist/commands/reply.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runReply = runReply;
+const shared_1 = require("./shared");
+const pingFiles_1 = require("./pingFiles");
+const USAGE = 'Usage: codiedev reply <ping-id> "<message>" [--file <path>]';
+/**
+ * Answer a ping. Unlike a fresh `codiedev ping` back, this threads under the
+ * original and marks it read + replied, so it stops counting as waiting.
+ */
+async function runReply(args) {
+    const { files, rest } = (0, pingFiles_1.takeFileArgs)(args);
+    const positional = rest.filter((a) => !a.startsWith("--"));
+    const pingId = positional[0];
+    // Join the rest in case the shell split the message despite quoting.
+    const body = (0, shared_1.stripQuotes)(positional.slice(1).join(" "));
+    if (!pingId || (!body && files.length === 0)) {
+        console.error(USAGE);
+        process.exit(1);
+    }
+    const config = (0, shared_1.requireConfig)();
+    const start = Date.now();
+    try {
+        const attachmentIds = await (0, pingFiles_1.uploadOrExit)(config, files);
+        const res = await (0, shared_1.apiRequest)("POST", "/api/cli/reply", {
+            config,
+            body: { pingId, body, ...(attachmentIds.length ? { attachmentIds } : {}) },
+        });
+        (0, shared_1.recordAgentEvent)(config, {
+            tool: "codiedev_reply",
+            ok: true,
+            latencyMs: Date.now() - start,
+        });
+        const to = res.recipient ? `${res.recipient.name} <${res.recipient.email}>` : "them";
+        const withFiles = files.length ? ` with ${files.length} file${files.length === 1 ? "" : "s"}` : "";
+        console.log(`✓ Replied to ${to}${withFiles}`);
+    }
+    catch (err) {
+        const e = err;
+        (0, shared_1.recordAgentEvent)(config, {
+            tool: "codiedev_reply",
+            ok: false,
+            latencyMs: Date.now() - start,
+            error: e.message,
+        });
+        if (e.status === 404 && /ping not found/.test(e.message)) {
+            console.error(`No ping ${pingId} addressed to you. Run 'codiedev inbox' for the ids.`);
+        }
+        else {
+            console.error(`Reply failed: ${e.message}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/shared.d.ts

@@ -21,6 +21,17 @@ export declare function apiRequest<T = unknown>(method: "GET" | "POST", path: st
     body?: Record<string, unknown>;
     query?: Record<string, string | number | undefined>;
 }): Promise<T>;
+/**
+ * Binary twin of apiRequest: GET returns the raw body; POST sends `body` as
+ * application/octet-stream and returns parsed JSON. Same auth and errors
+ * (`status` on non-2xx). Used for starter-pack files (SIG-127).
+ */
+export declare function apiRequestBytes(method: "GET" | "POST", path: string, options: {
+    config: CodiedevConfig;
+    body?: Buffer;
+    query?: Record<string, string | number | undefined>;
+    maxBytes?: number;
+}): Promise<Buffer>;
 /**
  * Fire-and-forget per-invocation telemetry from CLI subcommands. Mirrors
  * the MCP server's emitTelemetry but stamps `source: "cli"` so adoption

package/dist/commands/shared.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyConfigEnvOverrides = applyConfigEnvOverrides;
 exports.requireConfig = requireConfig;
 exports.apiRequest = apiRequest;
+exports.apiRequestBytes = apiRequestBytes;
 exports.recordAgentEvent = recordAgentEvent;
 exports.recordInstallEvent = recordInstallEvent;
 exports.withTelemetry = withTelemetry;
@@ -135,6 +136,62 @@ function apiRequest(method, path, options) {
         req.end();
     });
 }
+/**
+ * Binary twin of apiRequest: GET returns the raw body; POST sends `body` as
+ * application/octet-stream and returns parsed JSON. Same auth and errors
+ * (`status` on non-2xx). Used for starter-pack files (SIG-127).
+ */
+function apiRequestBytes(method, path, options) {
+    return new Promise((resolve, reject) => {
+        const url = new URL(path, options.config.backendUrl);
+        for (const [k, v] of Object.entries(options.query ?? {})) {
+            if (v !== undefined)
+                url.searchParams.set(k, String(v));
+        }
+        const lib = url.protocol === "https:" ? https : http;
+        const req = lib.request({
+            hostname: url.hostname,
+            port: url.port || (url.protocol === "https:" ? 443 : 80),
+            path: url.pathname + url.search,
+            method,
+            headers: {
+                Authorization: `Bearer ${options.config.token}`,
+                "X-Codiedev-Cli-Version": version_1.CLI_VERSION,
+                ...(options.body ? { "Content-Type": "application/octet-stream", "Content-Length": options.body.length } : {}),
+            },
+        }, (res) => {
+            const chunks = [];
+            let size = 0;
+            res.on("data", (c) => {
+                size += c.length;
+                if (options.maxBytes !== undefined && size > options.maxBytes) {
+                    req.destroy(Object.assign(new Error(`response over ${options.maxBytes} bytes`), { status: res.statusCode }));
+                    return;
+                }
+                chunks.push(c);
+            });
+            res.on("end", () => {
+                const buf = Buffer.concat(chunks);
+                if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300)
+                    return resolve(buf);
+                let message = `HTTP ${res.statusCode}`;
+                try {
+                    const parsed = JSON.parse(buf.toString("utf8"));
+                    if (parsed && typeof parsed.error === "string")
+                        message = parsed.error;
+                }
+                catch {
+                    // not JSON
+                }
+                reject(Object.assign(new Error(message), { status: res.statusCode }));
+            });
+        });
+        req.on("error", reject);
+        if (options.body)
+            req.write(options.body);
+        req.end();
+    });
+}
 /**
  * Fire-and-forget per-invocation telemetry from CLI subcommands. Mirrors
  * the MCP server's emitTelemetry but stamps `source: "cli"` so adoption

package/dist/hook.js

@@ -54,6 +54,7 @@ const selfUpdate_1 = require("./selfUpdate");
 const version_1 = require("./version");
 // --- starter packs (SIG-113 phase 2): autosync, nudge ---
 const sync_1 = require("./packs/sync");
+const unreadNotice_1 = require("./unreadNotice");
 // --- end starter packs ---
 const captureLog_1 = require("./captureLog");
 const subagents_1 = require("./subagents");
@@ -267,25 +268,28 @@ async function postSessionSkip(config, sessionId, reason) {
 }
 // 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).
+// transcript read, no git — so it never slows session startup. Best-effort.
+// The response may carry the person's unread-ping summary, which the caller
+// turns into a one-line notice; it rides on this request so the reminder
+// costs no extra round trip.
 async function runSessionStart(hookInput, source = "claude-code") {
     const config = (0, utils_1.readConfig)();
     if (!config)
-        return;
+        return undefined;
     if (hookInput.session_id) {
         try {
-            await postJson(`${config.backendUrl}/api/cli/sessionStart`, {
+            const res = await postJsonForResponse(`${config.backendUrl}/api/cli/sessionStart`, {
                 sessionId: hookInput.session_id,
                 startedAt: Date.now(),
                 source,
             }, config.token, PING_TIMEOUT_MS);
+            return res?.unreadPings;
         }
         catch {
             /* best-effort — never block session startup */
         }
     }
-    return;
+    return undefined;
 }
 function postJson(url, body, bearerToken, 
 // Socket timeout. Pass a SMALL value for tiny pings that run on (or near)
@@ -337,7 +341,10 @@ timeoutMs) {
 // postJson variant that returns the parsed response body — the upload-URL
 // handshake needs the { uploadUrl } the server hands back. No timeout: runs
 // only in detached uploader children, never on the shutdown clock.
-function postJsonForResponse(url, body, bearerToken) {
+function postJsonForResponse(url, body, bearerToken, 
+// Socket timeout for tiny pings on the session-start path: a black-holed
+// connection must not hang the hook. Unset = no timeout, as before.
+timeoutMs) {
     return new Promise((resolve, reject) => {
         const parsed = new URL(url);
         const data = JSON.stringify(body);
@@ -371,6 +378,11 @@ function postJsonForResponse(url, body, bearerToken) {
             });
         });
         req.on("error", reject);
+        if (timeoutMs) {
+            req.setTimeout(timeoutMs, () => {
+                req.destroy(new Error(`timeout after ${timeoutMs}ms`));
+            });
+        }
         req.write(data);
         req.end();
     });
@@ -658,7 +670,7 @@ async function main() {
         if (packNag && process.argv[2] === "session-start")
             process.stdout.write(`${packNag}\n`);
         // --- end starter packs ---
-        await runSessionStart(hookInput, process.argv[2] === "session-start-opencode"
+        const unreadPings = await runSessionStart(hookInput, process.argv[2] === "session-start-opencode"
             ? "opencode"
             : process.argv[2] === "session-start-cursor"
                 ? "cursor"
@@ -667,13 +679,21 @@ async function main() {
                     : process.argv[2] === "session-start-pi"
                         ? "pi"
                         : "claude-code");
+        // "A teammate is waiting on you." Claude Code reads SessionStart stdout
+        // into the session; Cursor and Copilot get it in their context below.
+        // OpenCode and pi ignore this hook's output, and Codex has no SessionStart.
+        const unreadNotice = process.argv[2] === "session-start-opencode" || process.argv[2] === "session-start-pi"
+            ? null
+            : (0, unreadNotice_1.takeUnreadNotice)(unreadPings);
+        if (unreadNotice && process.argv[2] === "session-start")
+            process.stdout.write(`${unreadNotice}\n`);
         if ((0, utils_1.readConfig)() && (process.argv[2] === "session-start-cursor" || process.argv[2] === "session-start-copilot")) {
             const source = process.argv[2] === "session-start-cursor" ? "cursor" : "copilot";
             const { TEAM_SKILL_CONTEXT, teamSkillSessionOutput } = await Promise.resolve().then(() => __importStar(require("./teamSkillContext")));
             const prompt = hookInput.initialPrompt
                 ?? hookInput.initial_prompt;
             const discovered = typeof prompt === "string" ? await discoverContext(prompt) : null;
-            process.stdout.write(JSON.stringify(teamSkillSessionOutput(source, [TEAM_SKILL_CONTEXT, discovered, packNag].filter(Boolean).join("\n\n"))));
+            process.stdout.write(JSON.stringify(teamSkillSessionOutput(source, [TEAM_SKILL_CONTEXT, discovered, packNag, unreadNotice].filter(Boolean).join("\n\n"))));
         }
         return;
     }

package/dist/inboxFormat.d.ts

@@ -11,7 +11,17 @@ export interface InboxPing {
         title?: string;
     } | null;
     preview: string;
+    attachments?: Array<{
+        name: string;
+        size: number;
+        url?: string | null;
+    }>;
 }
+/** "shard-timings.csv (66 B), trace.log (1.2 MB)" */
+export declare function fileList(files: Array<{
+    name: string;
+    size: number;
+}>): string;
 export interface InboxMention {
     mentionId: string;
     createdAt: number;

package/dist/inboxFormat.js

@@ -1,7 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileList = fileList;
 exports.formatInbox = formatInbox;
 const shared_1 = require("./commands/shared");
+function fileSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${Math.round(bytes / 1024)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+/** "shard-timings.csv (66 B), trace.log (1.2 MB)" */
+function fileList(files) {
+    return files.map((f) => `${f.name} (${fileSize(f.size)})`).join(", ");
+}
 /**
  * Render the inbox for BOTH surfaces — `codiedev inbox` and the MCP
  * `codiedev_inbox` tool an agent calls for "any messages?". Shared so the
@@ -47,6 +59,9 @@ function formatInbox(opts) {
         const where = p.subjectKey ? ` · on ${p.subjectKey}` : "";
         lines.push(`${dot}  ${from}${where} · ${(0, shared_1.timeAgo)(p.createdAt)}`);
         lines.push(`    ${p.preview || "(no body)"}`);
+        if (p.attachments?.length) {
+            lines.push(`    ${p.attachments.length === 1 ? "file" : "files"}: ${fileList(p.attachments)}`);
+        }
         lines.push(`    id: ${p.pingId}`);
         lines.push("");
     }
@@ -63,7 +78,9 @@ function formatInbox(opts) {
             lines.push(`    ${m.url}`);
         lines.push("");
     }
-    if (keptPings.length > 0)
+    if (keptPings.length > 0) {
         lines.push("Mark read: codiedev read <ping-id>");
+        lines.push('Reply:     codiedev reply <ping-id> "<message>"');
+    }
     return lines;
 }

package/dist/mcp.js

@@ -291,9 +291,7 @@ const TOOLS = [
             "when the user asks 'has anyone solved X?', 'find me the spec on Y', " +
             "or 'look for prior work on Z'. Always search before pushing a new " +
             "artifact so the user doesn't duplicate work. Returns ranked hits " +
-            "with title, type, filename key, and a snippet. For open-ended " +
-            "questions where the user wants a synthesized answer (not just a list " +
-            "of hits), prefer codiedev_ask instead.",
+            "with title, type, filename key, and a snippet.",
         inputSchema: {
             type: "object",
             properties: {
@@ -303,32 +301,6 @@ const TOOLS = [
             required: ["query"],
         },
     },
-    {
-        name: "codiedev_ask",
-        description: "Ask a natural-language question of the team's collective memory and " +
-            "get a synthesized answer with citations. Searches across both " +
-            "auto-extracted artifacts (specs / decisions / bugfixes) AND raw " +
-            "session transcripts, then has an LLM compose an answer that cites " +
-            "the actual sources. Use when the user asks 'why did we…?', 'what " +
-            "does the team know about X?', 'has anyone done Y here before?', " +
-            "'who decided Z and why?', or any open-ended question about prior " +
-            "work where they want context, not just a hit list. For exact-match " +
-            "lookups (find me spec-x), prefer codiedev_pull. For browsing or " +
-            "filtering by kind/tag, prefer codiedev_get_library. For surfacing " +
-            "ranked hits without LLM synthesis, prefer codiedev_search.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                question: {
-                    type: "string",
-                    description: "Natural-language question. Open-ended is fine — e.g. 'why " +
-                        "did we drop pg-bouncer?' or 'how does the team think about " +
-                        "feature flags?'.",
-                },
-            },
-            required: ["question"],
-        },
-    },
     {
         name: "codiedev_get_library",
         description: "List artifacts in the team library — both docs (spec / decision / " +
@@ -467,8 +439,6 @@ async function dispatchTool(name, args, config) {
             return await handleShareWith(args, config);
         case "codiedev_send_to":
             return await handleSendTo(args, config);
-        case "codiedev_ask":
-            return await handleAsk(args, config);
         case "codiedev_search":
             return await handleSearch(args, config);
         case "codiedev_get_library":
@@ -740,23 +710,6 @@ async function handleSearch(args, config) {
     }
     return { content: [{ type: "text", text: lines.join("\n") }] };
 }
-async function handleAsk(args, config) {
-    const question = asString(args.question);
-    if (!question)
-        throw new Error("question required");
-    const res = await (0, shared_1.apiRequest)("POST", "/api/cli/ask", { config, body: { question } });
-    const lines = [res.answer];
-    if (res.citations && res.citations.length > 0) {
-        lines.push("", "Sources:");
-        for (const c of res.citations) {
-            const label = c.kind === "artifact"
-                ? `[${c.type}] ${c.title}`
-                : `[session] ${c.title}`;
-            lines.push(`  • ${label}`);
-        }
-    }
-    return { content: [{ type: "text", text: lines.join("\n") }] };
-}
 async function handleGetLibrary(args, config) {
     const scope = asStringOrUndefined(args.scope);
     const type = asStringOrUndefined(args.type);

package/dist/packs/files.d.ts

@@ -0,0 +1,46 @@
+export declare const PACK_MAX_FILES = 500;
+export declare const PACK_FILE_MAX_BYTES: number;
+export declare const PACK_FILES_MAX_TOTAL_BYTES: number;
+export declare const SHA256_HEX: RegExp;
+export interface PackBundleFile {
+    path: string;
+    sha256: string;
+    size: number;
+    executable?: boolean;
+}
+/** Why a plugin-relative path can't be written, or null when it's fine. */
+export declare function packFilePathProblem(raw: unknown): string | null;
+export declare function blobsDir(root: string): string;
+export declare function blobPath(dir: string, sha256: string): string;
+export declare function sha256Of(buf: Buffer): string;
+/** Download every blob the manifest needs that isn't cached yet. Each body
+ * must match its sha256 and size or nothing is kept. */
+export declare function ensureBlobs(dir: string, files: PackBundleFile[], download: (file: PackBundleFile) => Promise<Buffer>): Promise<{
+    downloaded: number;
+}>;
+export interface FilesEntry {
+    dest: string;
+    source: string;
+    line: number;
+}
+/** The `## Files` section of a pack.md, or null when there is none (then
+ * `pack apply` leaves the pack's files alone). Fenced blocks are skipped so
+ * agent bodies can't open a section. */
+export declare function parseFilesSection(markdown: string): FilesEntry[] | null;
+/** pack.md with its `## Files` section (heading and body) removed. */
+export declare function stripFilesSection(markdown: string): string;
+export interface LocalFile extends PackBundleFile {
+    abs: string;
+}
+export declare function expandHome(p: string, home?: string): string;
+/** Walk each `## Files` entry. Junk (caches, VCS, editor files) is skipped
+ * quietly; symlinks, hidden files and a skill folder's own SKILL.md are
+ * skipped with a note. Throws on a missing source or a bad destination. */
+export declare function collectLocalFiles(entries: FilesEntry[], baseDir: string, home?: string): {
+    files: LocalFile[];
+    notes: string[];
+};
+/** Only Claude Code sets ${CLAUDE_PLUGIN_ROOT}. In the copy other tools read,
+ * replace it with the plugin dir's real path (forward slashes, which every
+ * shell and Python accept, Windows included). */
+export declare function rewritePluginRoot(content: string, pluginRoot: string): string;