codiedev 0.10.0-beta.4 → 0.10.0-beta.5

package/dist/subagents.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUBAGENT_LIMITS = void 0;
+exports.subagentDir = subagentDir;
+exports.readSubagentTranscripts = readSubagentTranscripts;
+exports.foldSubagentSignals = foldSubagentSignals;
+exports.foldSubagentModelUsage = foldSubagentModelUsage;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const captureSignals_1 = require("./captureSignals");
+const transcriptModels_1 = require("./transcriptModels");
+exports.SUBAGENT_LIMITS = { files: 20, bytes: 20 * 1024 * 1024 };
+function subagentDir(transcriptPath, sessionId) {
+    const dir = node_path_1.default.dirname(transcriptPath);
+    const id = sessionId || node_path_1.default.basename(transcriptPath).replace(/\.jsonl$/i, "");
+    return node_path_1.default.join(dir, id, "subagents");
+}
+function readSubagentTranscripts(transcriptPath, sessionId, limits = exports.SUBAGENT_LIMITS) {
+    const dir = subagentDir(transcriptPath, sessionId);
+    let names;
+    try {
+        names = node_fs_1.default.readdirSync(dir).filter((n) => /^agent-[^/]+\.jsonl$/.test(n));
+    }
+    catch {
+        return { contents: [], count: 0, truncated: false };
+    }
+    const files = names
+        .map((n) => {
+        const full = node_path_1.default.join(dir, n);
+        try {
+            const st = node_fs_1.default.statSync(full);
+            return st.isFile() ? { full, size: st.size, mtime: st.mtimeMs } : null;
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((f) => f !== null)
+        .sort((a, b) => a.mtime - b.mtime || a.full.localeCompare(b.full));
+    const contents = [];
+    let bytes = 0;
+    let truncated = false;
+    for (const f of files) {
+        if (contents.length >= limits.files || bytes + f.size > limits.bytes) {
+            truncated = true;
+            break;
+        }
+        try {
+            contents.push(node_fs_1.default.readFileSync(f.full, "utf8"));
+            bytes += f.size;
+        }
+        catch {
+            truncated = true;
+        }
+    }
+    return { contents, count: files.length, truncated };
+}
+function foldSubagentSignals(parent, subs, source) {
+    if (subs.count === 0)
+        return parent;
+    const counts = new Map();
+    const add = (list, fallback) => {
+        for (const c of list ?? fallback.map((skill) => ({ skill, count: 1 })))
+            counts.set(c.skill, (counts.get(c.skill) ?? 0) + c.count);
+    };
+    add(parent.skillInvocationCounts, parent.skillInvocations);
+    const invocations = new Set(parent.skillInvocations);
+    const pulls = new Set(parent.skillPulls);
+    const tools = new Map(parent.toolCalls.map((t) => [t.name, t.calls]));
+    const artifacts = new Map((parent.skillInvocationArtifacts ?? []).map((a) => [a.skill, a.artifactId]));
+    let truncated = parent.truncated;
+    for (const content of subs.contents) {
+        const s = (0, captureSignals_1.parseCaptureSignals)(content, source);
+        add(s.skillInvocationCounts, s.skillInvocations);
+        for (const a of s.skillInvocationArtifacts ?? [])
+            if (!artifacts.has(a.skill))
+                artifacts.set(a.skill, a.artifactId);
+        for (const k of s.skillInvocations)
+            invocations.add(k);
+        for (const k of s.skillPulls)
+            pulls.add(k);
+        for (const t of s.toolCalls)
+            tools.set(t.name, (tools.get(t.name) ?? 0) + t.calls);
+        truncated ||= s.truncated;
+    }
+    const cap = (xs) => {
+        if (xs.length > 100)
+            truncated = true;
+        return xs.slice(0, 100);
+    };
+    return {
+        ...parent,
+        skillInvocations: cap([...invocations].sort()),
+        skillInvocationCounts: cap([...counts].map(([skill, count]) => ({ skill, count: Math.min(count, 10_000) })).sort((a, b) => a.skill.localeCompare(b.skill))),
+        ...(artifacts.size
+            ? { skillInvocationArtifacts: cap([...artifacts].map(([skill, artifactId]) => ({ skill, artifactId })).sort((a, b) => a.skill.localeCompare(b.skill))) }
+            : {}),
+        skillPulls: cap([...pulls].sort()),
+        toolCalls: cap([...tools].map(([name, calls]) => ({ name, calls })).sort((a, b) => a.name.localeCompare(b.name))),
+        subagents: { count: subs.count, truncated: subs.truncated },
+        truncated,
+    };
+}
+function foldSubagentModelUsage(parent, subs, source) {
+    if (subs.contents.length === 0)
+        return parent;
+    const byModel = new Map();
+    const add = (u) => {
+        const cur = byModel.get(u.model);
+        if (!cur) {
+            byModel.set(u.model, { ...u });
+            return;
+        }
+        cur.requests += u.requests;
+        cur.inputTokens += u.inputTokens;
+        cur.outputTokens += u.outputTokens;
+        cur.cacheReadTokens += u.cacheReadTokens;
+        cur.cacheCreationTokens += u.cacheCreationTokens;
+        if (u.costUsd !== undefined)
+            cur.costUsd = (cur.costUsd ?? 0) + u.costUsd;
+        if (u.reportedCostUsd !== undefined)
+            cur.reportedCostUsd = (cur.reportedCostUsd ?? 0) + u.reportedCostUsd;
+        if (u.reasoningTokens !== undefined)
+            cur.reasoningTokens = (cur.reasoningTokens ?? 0) + u.reasoningTokens;
+    };
+    for (const u of parent)
+        add(u);
+    for (const content of subs.contents)
+        for (const u of (0, transcriptModels_1.parseTranscriptModels)(content, source))
+            add(u);
+    return [...byModel.values()].slice(0, 64);
+}

package/dist/teamSkillContext.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEAM_SKILL_CONTEXT = void 0;
+exports.teamSkillSessionOutput = teamSkillSessionOutput;
+exports.TEAM_SKILL_CONTEXT = `This machine is connected to Codiedev, the team's artifact and skill library.
+Before a substantial coding task, run codiedev search "<brief task description>" and reuse a relevant team skill by running codiedev pull <exact-key> and following its instructions. If no skill fits, continue the task.
+Use codiedev push <file.md> to share an artifact when asked, codiedev ask "<question>" for team knowledge, and codiedev inbox to check messages. Use codiedev --help for other commands. If codiedev is unavailable, use npx codiedev@latest.`;
+function teamSkillSessionOutput(source, context = exports.TEAM_SKILL_CONTEXT) {
+    return source === "cursor" ? { additional_context: context } : { additionalContext: context };
+}

package/dist/transcriptModels.js

@@ -25,7 +25,6 @@ function* transcriptRecords(content, source) {
             }
         }
         catch {
-            /* Fall through to JSONL for partial captures. */
         }
     }
     let start = 0;
@@ -36,7 +35,6 @@ function* transcriptRecords(content, source) {
             yield JSON.parse(content.slice(start, end));
         }
         catch {
-            /* partial or non-JSON line */
         }
         start = end + 1;
     }
@@ -44,6 +42,7 @@ function* transcriptRecords(content, source) {
 function parseTranscriptModels(content, source) {
     const buckets = new Map();
     const messages = new Map();
+    const tokenEvidence = new Set();
     let model = "Unattributed";
     let previous = {
         inputTokens: 0,
@@ -75,8 +74,6 @@ function parseTranscriptModels(content, source) {
                 cacheReadTokens: positive(raw.cached_input_tokens),
                 cacheCreationTokens: 0,
             };
-            // Codex reasoning_output_tokens is a subset of output_tokens. Cumulative
-            // snapshots must be differenced, including across a model switch.
             usage = { ...empty(model), requests: 1 };
             const reset = positive(raw.input_tokens) <
                 previous.inputTokens + previous.cacheReadTokens ||
@@ -143,9 +140,10 @@ function parseTranscriptModels(content, source) {
             model =
                 typeof message.model === "string" ? message.model : "Unattributed";
             const raw = message.usage;
+            const requests = event.requests;
             usage = {
                 ...empty(model),
-                requests: 1,
+                requests: typeof requests === "number" && Number.isFinite(requests) ? Math.max(0, requests) : 1,
                 inputTokens: positive(raw.input_tokens),
                 outputTokens: positive(raw.output_tokens),
                 cacheReadTokens: positive(raw.cache_read_input_tokens),
@@ -153,10 +151,10 @@ function parseTranscriptModels(content, source) {
             };
             messageId = message.id ?? event.uuid ?? messageId;
         }
-        // Client placeholders are not model executions.
+        if (source === "copilot" && event.type === "copilot.usage")
+            tokenEvidence.add(usage.model);
         if (!usage.model.trim() || usage.model.startsWith("<"))
             continue;
-        // Streaming snapshots repeat message ids; retain the latest snapshot once.
         messages.set(messageId, usage);
     }
     const incompleteCosts = new Set();
@@ -197,7 +195,7 @@ function parseTranscriptModels(content, source) {
         delete buckets.get(key).costUsd;
     for (const key of incompleteReasoning)
         delete buckets.get(key).reasoningTokens;
-    return [...buckets.values()];
+    return [...buckets.values()].map(row => source === "copilot" && !tokenEvidence.has(row.model) ? { ...row, tokensAvailable: false } : row);
 }
 function totalModelTokens(row) {
     return (row.inputTokens +

package/dist/upgradeNudge.js

@@ -1,13 +1,4 @@
 "use strict";
-// Client-side "you're outdated" warning. Prints at the top of connect/doctor
-// when there's a newer `codiedev` published on npm. Pure helpers tested in
-// __tests__/versionCheck.test.ts; this module does the IO (registry fetch +
-// disk cache) and is exercised by manual smoke.
-//
-// Cache lives at <codiedevStateDir()>/.update-cache.json (~/.codiedev by
-// default; ~/.codiedev-desktop under CODIEDEV_CONFIG_DIR). 24h TTL — long
-// enough that the registry isn't hit on every command, short enough that
-// newly-published versions surface the day after release.
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -75,7 +66,6 @@ function writeCache(entry) {
         fs.writeFileSync(CACHE_PATH, JSON.stringify(entry), "utf8");
     }
     catch {
-        // ignore — cache is best-effort
     }
 }
 async function fetchLatestFromNpm() {
@@ -96,12 +86,6 @@ async function fetchLatestFromNpm() {
         return null;
     }
 }
-/**
- * Fail-silent — never throws, never blocks on network. If the registry is
- * unreachable or the cache is corrupt, the warning just doesn't print. The
- * worst outcome is "user keeps running an old version" — same as before
- * this feature existed.
- */
 async function maybePrintUpgradeNudge() {
     const now = Date.now();
     const cache = readCache();
@@ -126,9 +110,6 @@ async function maybePrintUpgradeNudge() {
     }
 }
 const OFFER_CACHE_NAME = ".update-offer-cache.json";
-// This runs before the harness paints, so the timeout is startup latency the
-// user feels. A missed check costs nothing; the next stale-cache launch tries
-// again.
 const OFFER_FETCH_TIMEOUT_MS = 1500;
 const UPGRADE_TIMEOUT_MS = 120_000;
 function offerCachePath(env) {
@@ -152,8 +133,6 @@ function readOfferCache(env) {
         return null;
     }
 }
-// If this cannot be persisted, the whole feature stays off. Without memory,
-// every launch would refetch and re-nag on ephemeral or read-only filesystems.
 function writeOfferCache(entry, env) {
     try {
         const target = offerCachePath(env);
@@ -190,8 +169,6 @@ async function fetchLatest(fetchImpl) {
         return null;
     }
 }
-// Single-keypress y/n prompt. EOF, Ctrl-C, lost raw mode, and tty errors all
-// default to no so update handling can never strand the launcher.
 function promptYesNo(question) {
     return new Promise((resolve) => {
         const stdin = process.stdin;
@@ -218,7 +195,6 @@ function promptYesNo(question) {
                 stdin.setRawMode(Boolean(wasRaw));
             }
             catch {
-                // Best-effort; the engine resets the tty when it starts.
             }
             stdin.pause();
             process.stdout.write(`${yes ? "y" : "n"}\n`);
@@ -239,11 +215,6 @@ function runUpgrade() {
     });
     return !result.error && result.status === 0;
 }
-/**
- * Prompt-capable sibling of maybePrintUpgradeNudge. Call this before handing
- * the terminal to a TUI. A successful upgrade relaunches the fresh CLI and
- * tells the stale caller to stop rather than continuing with old modules.
- */
 async function maybeOfferUpgrade(opts = {}) {
     const env = opts.env ?? process.env;
     const argv = opts.argv ?? process.argv;
@@ -257,7 +228,6 @@ async function maybeOfferUpgrade(opts = {}) {
     let fetchedAt = cache?.fetchedAt ?? 0;
     const promptedAt = cache?.promptedAt ?? 0;
     if (!cache || nowMs - cache.fetchedAt > CACHE_TTL_MS) {
-        // Probe writability before paying the network cost.
         if (!writeOfferCache(cache ?? { latest: null, fetchedAt: 0, promptedAt: 0 }, env)) {
             return { relaunched: false };
         }