@bububuger/spanory 0.1.15 → 0.1.18

package/dist/issue/state.js

@@ -0,0 +1,151 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+export const ISSUE_STATUSES = ['open', 'in_progress', 'blocked', 'done'];
+function nowIso(now) {
+    return now ?? new Date().toISOString();
+}
+function normalizeId(id) {
+    return String(id ?? '').trim();
+}
+function assertStatus(status) {
+    if (!ISSUE_STATUSES.includes(status)) {
+        throw new Error(`unsupported issue status: ${status}`);
+    }
+}
+function assertAllowedTransition(from, to) {
+    if (from === to)
+        return;
+    if (from === 'done' && to !== 'done') {
+        throw new Error('cannot transition issue from done to non-done status');
+    }
+}
+export function parsePendingTodoItems(todoContent, source = 'todo.md') {
+    const lines = String(todoContent ?? '').split(/\r?\n/);
+    const items = [];
+    for (const line of lines) {
+        const m = line.match(/^\s*-\s*\[\s\]\s+([A-Za-z0-9_-]+)\s+(.*)$/);
+        if (!m)
+            continue;
+        items.push({
+            id: normalizeId(m[1]),
+            title: m[2].trim(),
+            source,
+        });
+    }
+    return items;
+}
+export function syncIssueState(prev, pending, now) {
+    const timestamp = nowIso(now);
+    const byId = new Map(prev.issues.map((issue) => [issue.id, issue]));
+    const activeIds = new Set(pending.map((item) => item.id));
+    let added = 0;
+    let reopened = 0;
+    let autoClosed = 0;
+    for (const item of pending) {
+        const existing = byId.get(item.id);
+        if (!existing) {
+            byId.set(item.id, {
+                id: item.id,
+                title: item.title,
+                source: item.source,
+                status: 'open',
+                notes: ['synced from todo pending item'],
+                createdAt: timestamp,
+                updatedAt: timestamp,
+            });
+            added += 1;
+            continue;
+        }
+        existing.title = item.title;
+        existing.source = item.source;
+        existing.updatedAt = timestamp;
+        if (existing.status === 'done') {
+            existing.status = 'open';
+            existing.closedAt = undefined;
+            existing.notes.push('reopened by todo pending item');
+            reopened += 1;
+        }
+    }
+    for (const issue of byId.values()) {
+        if (issue.source !== 'todo.md')
+            continue;
+        if (activeIds.has(issue.id))
+            continue;
+        if (issue.status === 'done')
+            continue;
+        issue.status = 'done';
+        issue.updatedAt = timestamp;
+        issue.closedAt = timestamp;
+        issue.notes.push('auto-closed because todo item is no longer pending');
+        autoClosed += 1;
+    }
+    return {
+        state: {
+            version: 1,
+            updatedAt: timestamp,
+            issues: Array.from(byId.values()).sort((a, b) => a.id.localeCompare(b.id)),
+        },
+        added,
+        reopened,
+        autoClosed,
+    };
+}
+export function setIssueStatus(prev, input, now) {
+    const issueId = normalizeId(input.id);
+    const timestamp = nowIso(now);
+    assertStatus(input.status);
+    const issue = prev.issues.find((item) => item.id === issueId);
+    if (!issue)
+        throw new Error(`issue not found: ${issueId}`);
+    assertAllowedTransition(issue.status, input.status);
+    issue.status = input.status;
+    issue.updatedAt = timestamp;
+    if (input.status === 'done')
+        issue.closedAt = timestamp;
+    if (input.status !== 'done')
+        issue.closedAt = undefined;
+    if (input.note && input.note.trim())
+        issue.notes.push(input.note.trim());
+    return {
+        version: 1,
+        updatedAt: timestamp,
+        issues: prev.issues,
+    };
+}
+export function createEmptyIssueState(now) {
+    return {
+        version: 1,
+        updatedAt: nowIso(now),
+        issues: [],
+    };
+}
+export async function loadIssueState(filePath) {
+    try {
+        const raw = await readFile(filePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!parsed || !Array.isArray(parsed.issues)) {
+            throw new Error('invalid issue state file');
+        }
+        return {
+            version: 1,
+            updatedAt: String(parsed.updatedAt ?? new Date(0).toISOString()),
+            issues: parsed.issues,
+        };
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            return createEmptyIssueState();
+        }
+        throw error;
+    }
+}
+export async function saveIssueState(filePath, state) {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, `${JSON.stringify(state, null, 2)}\n`, 'utf-8');
+}
+export function resolveIssueStatePath(input) {
+    return input ? path.resolve(process.cwd(), input) : path.resolve(process.cwd(), 'docs/issues/state.json');
+}
+export function resolveTodoPath(input) {
+    return input ? path.resolve(process.cwd(), input) : path.resolve(process.cwd(), 'todo.md');
+}

package/dist/otlp.d.ts

@@ -1,5 +1,5 @@
 import { buildResource } from '../../otlp-core/dist/index.js';
 export { buildResource };
-export declare function parseHeaders(input: any): any;
-export declare function compileOtlp(events: any, resource: any): any;
+export declare function parseHeaders(input: any): Record<string, string>;
+export declare function compileOtlp(events: any, resource: any): import("../../otlp-core/dist/index.js").OtlpPayload;
 export declare function sendOtlp(endpoint: any, payload: any, headers?: {}): Promise<void>;

package/dist/report/aggregate.d.ts

@@ -19,3 +19,4 @@ export declare function summarizeTools(sessions: any): {
     sessions: any;
 }[];
 export declare function summarizeTurnDiff(sessions: any): any[];
+export declare function summarizeContext(sessions: any): any;

package/dist/report/aggregate.js

@@ -26,6 +26,32 @@ function usageFromEvent(event) {
     const total = toNumber(attrs['gen_ai.usage.total_tokens']) || input + output;
     return { input, output, total };
 }
+function parseJsonObject(value) {
+    if (typeof value !== 'string' || !value.trim())
+        return null;
+    try {
+        const parsed = JSON.parse(value);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+            return parsed;
+    }
+    catch {
+        // ignore parse errors
+    }
+    return null;
+}
+function parseJsonArray(value) {
+    if (typeof value !== 'string' || !value.trim())
+        return [];
+    try {
+        const parsed = JSON.parse(value);
+        if (Array.isArray(parsed))
+            return parsed;
+    }
+    catch {
+        // ignore parse errors
+    }
+    return [];
+}
 export async function loadExportedEvents(inputPath) {
     const inputStat = await stat(inputPath);
     const files = [];
@@ -141,8 +167,8 @@ export function summarizeCache(sessions) {
         for (const turn of turns) {
             const attrs = turn.attributes ?? {};
             inputTokens += toNumber(attrs['gen_ai.usage.input_tokens']);
-            cacheReadInputTokens += toNumber(attrs['gen_ai.usage.details.cache_read_input_tokens']);
-            cacheCreationInputTokens += toNumber(attrs['gen_ai.usage.details.cache_creation_input_tokens']);
+            cacheReadInputTokens += toNumber(attrs['gen_ai.usage.cache_read.input_tokens']);
+            cacheCreationInputTokens += toNumber(attrs['gen_ai.usage.cache_creation.input_tokens']);
             const hitRate = toOptionalNumber(attrs['gen_ai.usage.details.cache_hit_rate']);
             if (hitRate !== undefined)
                 explicitHitRates.push(hitRate);
@@ -243,3 +269,103 @@ export function summarizeTurnDiff(sessions) {
     }
     return rows;
 }
+export function summarizeContext(sessions) {
+    return sessions.map((s) => {
+        const events = s.events ?? [];
+        const snapshots = events.filter((e) => e?.attributes?.['agentic.context.event_type'] === 'context_snapshot');
+        const boundaries = events.filter((e) => e?.attributes?.['agentic.context.event_type'] === 'context_boundary');
+        const attributions = events.filter((e) => e?.attributes?.['agentic.context.event_type'] === 'context_source_attribution');
+        let maxFillRatio = 0;
+        let maxDeltaTokens = 0;
+        for (const snapshot of snapshots) {
+            const attrs = snapshot.attributes ?? {};
+            const fillRatio = toOptionalNumber(attrs['agentic.context.fill_ratio']) ?? 0;
+            const deltaTokens = toOptionalNumber(attrs['agentic.context.delta_tokens']) ?? 0;
+            maxFillRatio = Math.max(maxFillRatio, fillRatio);
+            maxDeltaTokens = Math.max(maxDeltaTokens, deltaTokens);
+        }
+        const compactCount = boundaries.filter((e) => String(e?.attributes?.['agentic.context.boundary_kind'] ?? '') === 'compact_after').length;
+        const last5 = snapshots.slice(-5);
+        let unknownTokens = 0;
+        let totalTokens = 0;
+        for (const snapshot of last5) {
+            const composition = parseJsonObject(snapshot?.attributes?.['agentic.context.composition']);
+            if (!composition)
+                continue;
+            for (const [kind, raw] of Object.entries(composition)) {
+                const value = Number(raw);
+                if (!Number.isFinite(value) || value <= 0)
+                    continue;
+                totalTokens += value;
+                if (kind === 'unknown')
+                    unknownTokens += value;
+            }
+        }
+        const unknownDeltaShareWindow5 = totalTokens > 0 ? round6(unknownTokens / totalTokens) : 0;
+        let unknownTopStreak = 0;
+        let runningUnknown = 0;
+        for (const snapshot of snapshots) {
+            const topSources = parseJsonArray(snapshot?.attributes?.['agentic.context.top_sources']);
+            const top = String(topSources[0] ?? '').trim();
+            if (top === 'unknown') {
+                runningUnknown += 1;
+                unknownTopStreak = Math.max(unknownTopStreak, runningUnknown);
+            }
+            else {
+                runningUnknown = 0;
+            }
+        }
+        let highPollutionSourceStreak = 0;
+        const turnOrder = [];
+        const highByTurn = new Map();
+        for (const event of attributions) {
+            const attrs = event?.attributes ?? {};
+            const turnId = String(event?.turnId ?? '');
+            if (!turnId)
+                continue;
+            if (!highByTurn.has(turnId)) {
+                highByTurn.set(turnId, []);
+                turnOrder.push(turnId);
+            }
+            const sourceKind = String(attrs['agentic.context.source_kind'] ?? '').trim();
+            const score = Number(attrs['agentic.context.pollution_score']);
+            if (!sourceKind || !Number.isFinite(score) || score < 80)
+                continue;
+            highByTurn.get(turnId).push({ sourceKind, score });
+        }
+        let runningSource = '';
+        let runningCount = 0;
+        for (const turnId of turnOrder) {
+            const items = highByTurn.get(turnId) ?? [];
+            if (!items.length) {
+                runningSource = '';
+                runningCount = 0;
+                continue;
+            }
+            items.sort((a, b) => b.score - a.score);
+            const topSource = items[0].sourceKind;
+            if (topSource === runningSource) {
+                runningCount += 1;
+            }
+            else {
+                runningSource = topSource;
+                runningCount = 1;
+            }
+            highPollutionSourceStreak = Math.max(highPollutionSourceStreak, runningCount);
+        }
+        return {
+            projectId: s.context.projectId ?? events[0]?.projectId,
+            sessionId: s.context.sessionId ?? events[0]?.sessionId,
+            runtime: events[0]?.runtime,
+            snapshots: snapshots.length,
+            boundaries: boundaries.length,
+            compactCount,
+            attributions: attributions.length,
+            maxFillRatio: round6(maxFillRatio),
+            maxDeltaTokens,
+            unknownDeltaShareWindow5,
+            unknownTopStreak,
+            highPollutionSourceStreak,
+        };
+    });
+}

package/dist/runtime/claude/adapter.js

@@ -1,8 +1,9 @@
 // @ts-nocheck
-import { readFile } from 'node:fs/promises';
+import { readdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { RUNTIME_CAPABILITIES } from '../shared/capabilities.js';
 import { normalizeTranscriptMessages, parseProjectIdFromTranscriptPath, pickUsage } from '../shared/normalize.js';
+const INFER_WINDOW_EPSILON_MS = 1200;
 function parseTimestamp(entry) {
     const raw = entry?.timestamp;
     const date = raw ? new Date(raw) : new Date();
@@ -17,6 +18,150 @@ function normalizeIsSidechain(entry) {
 function normalizeAgentId(entry) {
     return entry?.agentId ?? entry?.agent_id ?? entry?.message?.agentId ?? entry?.message?.agent_id;
 }
+function extractToolUses(content) {
+    if (!Array.isArray(content))
+        return [];
+    return content.filter((block) => block && typeof block === 'object' && block.type === 'tool_use');
+}
+function extractToolResults(content) {
+    if (!Array.isArray(content))
+        return [];
+    return content.filter((block) => block && typeof block === 'object' && block.type === 'tool_result');
+}
+function isToolResultOnlyContent(content) {
+    return Array.isArray(content)
+        && content.length > 0
+        && content.every((block) => block && typeof block === 'object' && block.type === 'tool_result');
+}
+function isPromptUserMessage(message) {
+    if (!message || message.role !== 'user' || message.isMeta)
+        return false;
+    const { content } = message;
+    if (typeof content === 'string')
+        return content.trim().length > 0;
+    if (!Array.isArray(content))
+        return false;
+    if (isToolResultOnlyContent(content))
+        return false;
+    return content.length > 0;
+}
+function firstNonEmpty(values) {
+    for (const value of values) {
+        const text = String(value ?? '').trim();
+        if (text)
+            return text;
+    }
+    return '';
+}
+function findChildSessionHints(messages) {
+    const hasSidechainSignal = messages.some((m) => m?.isSidechain === true || String(m?.agentId ?? '').trim().length > 0);
+    if (!hasSidechainSignal)
+        return null;
+    const hasParentLink = messages.some((m) => String(m?.parentSessionId ?? m?.parent_session_id ?? '').trim().length > 0
+        || String(m?.parentTurnId ?? m?.parent_turn_id ?? '').trim().length > 0
+        || String(m?.parentToolCallId ?? m?.parent_tool_call_id ?? '').trim().length > 0);
+    if (hasParentLink)
+        return null;
+    const sorted = [...messages].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    const childStartedAt = sorted[0]?.timestamp;
+    if (!childStartedAt)
+        return null;
+    return {
+        childStartedAt,
+        agentId: firstNonEmpty(messages.map((m) => m?.agentId)),
+    };
+}
+function extractTaskWindows(messages, sessionId) {
+    const sorted = [...messages].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    const windows = [];
+    const byCallId = new Map();
+    let turnIndex = 0;
+    let currentTurnId = 'turn-1';
+    for (const msg of sorted) {
+        if (isPromptUserMessage(msg)) {
+            turnIndex += 1;
+            currentTurnId = `turn-${turnIndex}`;
+        }
+        if (msg.role === 'assistant') {
+            for (const tu of extractToolUses(msg.content)) {
+                const toolName = String(tu.name ?? '').trim();
+                if (toolName !== 'Task')
+                    continue;
+                const callId = String(tu.id ?? '').trim();
+                if (!callId)
+                    continue;
+                const window = {
+                    parentSessionId: sessionId,
+                    parentTurnId: currentTurnId,
+                    parentToolCallId: callId,
+                    startedAtMs: msg.timestamp.getTime(),
+                    endedAtMs: msg.timestamp.getTime(),
+                };
+                windows.push(window);
+                byCallId.set(callId, window);
+            }
+        }
+        if (msg.role === 'user') {
+            for (const tr of extractToolResults(msg.content)) {
+                const callId = String(tr.tool_use_id ?? tr.toolUseId ?? '').trim();
+                if (!callId)
+                    continue;
+                const window = byCallId.get(callId);
+                if (window) {
+                    window.endedAtMs = Math.max(window.endedAtMs, msg.timestamp.getTime());
+                }
+            }
+        }
+    }
+    return windows;
+}
+async function inferParentLinkFromSiblingSessions({ transcriptPath, messages }) {
+    const hints = findChildSessionHints(messages);
+    if (!hints)
+        return messages;
+    const currentSessionId = path.basename(transcriptPath, '.jsonl');
+    const dir = path.dirname(transcriptPath);
+    let entries = [];
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return messages;
+    }
+    const candidates = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith('.jsonl'))
+            continue;
+        const siblingSessionId = entry.name.slice(0, -'.jsonl'.length);
+        if (siblingSessionId === currentSessionId)
+            continue;
+        const siblingPath = path.join(dir, entry.name);
+        const siblingMessages = await readClaudeTranscript(siblingPath);
+        const windows = extractTaskWindows(siblingMessages, siblingSessionId);
+        for (const window of windows) {
+            const childAtMs = hints.childStartedAt.getTime();
+            const lower = window.startedAtMs - INFER_WINDOW_EPSILON_MS;
+            const upper = window.endedAtMs + INFER_WINDOW_EPSILON_MS;
+            if (childAtMs < lower || childAtMs > upper)
+                continue;
+            candidates.push({
+                ...window,
+                score: Math.abs(childAtMs - window.startedAtMs),
+            });
+        }
+    }
+    if (candidates.length === 0)
+        return messages;
+    candidates.sort((a, b) => a.score - b.score);
+    const best = candidates[0];
+    return messages.map((msg) => ({
+        ...msg,
+        parentSessionId: best.parentSessionId,
+        parentTurnId: best.parentTurnId,
+        parentToolCallId: best.parentToolCallId,
+        parentLinkConfidence: 'inferred',
+    }));
+}
 async function readClaudeTranscript(transcriptPath) {
     const raw = await readFile(transcriptPath, 'utf-8');
     const lines = raw.split('\n').map((line) => line.trim()).filter(Boolean);
@@ -29,6 +174,9 @@ async function readClaudeTranscript(transcriptPath) {
                 isMeta: entry.isMeta ?? false,
                 isSidechain: normalizeIsSidechain(entry),
                 agentId: normalizeAgentId(entry),
+                parentSessionId: entry?.parentSessionId ?? entry?.parent_session_id,
+                parentTurnId: entry?.parentTurnId ?? entry?.parent_turn_id,
+                parentToolCallId: entry?.parentToolCallId ?? entry?.parent_tool_call_id,
                 content: entry?.message?.content ?? entry.content ?? '',
                 model: entry?.message?.model ?? entry.model,
                 usage: pickUsage(entry?.message?.usage ?? entry?.usage ?? entry?.message_usage),
@@ -62,7 +210,8 @@ export const claudeCodeAdapter = {
     async collectEvents(context) {
         const transcriptPath = context.transcriptPath ??
             path.join(process.env.HOME || '', '.claude', 'projects', context.projectId, `${context.sessionId}.jsonl`);
-        const messages = await readClaudeTranscript(transcriptPath);
+        const loaded = await readClaudeTranscript(transcriptPath);
+        const messages = await inferParentLinkFromSiblingSessions({ transcriptPath, messages: loaded });
         return normalizeTranscriptMessages({
             runtime: 'claude-code',
             projectId: context.projectId,

package/dist/runtime/codex/adapter.js

@@ -60,7 +60,7 @@ function sanitizeProjectBase(name) {
 }
 function deriveProjectIdFromCwd(cwd) {
     const base = sanitizeProjectBase(path.basename(String(cwd ?? '').trim()) || 'codex');
-    const hash = createHash('sha1').update(String(cwd ?? '')).digest('hex').slice(0, 6);
+    const hash = createHash('sha1').update(String(cwd ?? '')).digest('hex').slice(0, 10);
     return `${base}-${hash}`;
 }
 function usageFromTotals(start, end) {
@@ -77,6 +77,21 @@ function usageFromTotals(start, end) {
         total_tokens: total || input + output,
     });
 }
+function extractPtySessionId(output) {
+    const text = String(output ?? '');
+    const match = text.match(/session ID\s+(\d+)/i);
+    return match ? match[1] : undefined;
+}
+function extractWallTimeMs(output) {
+    const text = String(output ?? '');
+    const match = text.match(/Wall time:\s*([0-9]+(?:\.[0-9]+)?)\s*seconds?/i);
+    if (!match)
+        return undefined;
+    const seconds = Number(match[1]);
+    if (!Number.isFinite(seconds) || seconds <= 0)
+        return undefined;
+    return Math.floor(seconds * 1000);
+}
 function createTurn(turnId, startedAt) {
     return {
         turnId,
@@ -194,6 +209,7 @@ async function readCodexSession(transcriptPath) {
     let sessionMeta = null;
     let callCounter = 0;
     const callIndex = new Map();
+    const ptyCallBySession = new Map();
     function finalizeCurrentTurn(at) {
         if (!currentTurn)
             return;
@@ -323,6 +339,11 @@ async function readCodexSession(transcriptPath) {
             const rawName = payload.name ?? payload.tool_name ?? payload.toolName;
             const rawInput = payload.type === 'custom_tool_call' ? payload.input : payload.arguments;
             const args = safeJsonParse(rawInput, typeof rawInput === 'string' ? { raw: rawInput } : {});
+            const ptySessionId = args.session_id != null ? String(args.session_id) : '';
+            if (String(rawName ?? '') === 'write_stdin' && ptySessionId && ptyCallBySession.has(ptySessionId)) {
+                callIndex.set(String(payload.call_id ?? payload.callId ?? `call-${callCounter}`), ptyCallBySession.get(ptySessionId));
+                continue;
+            }
             const normalized = normalizeToolCall(rawName, args, callCounter);
             const callId = String(payload.call_id ?? payload.callId ?? normalized.callId ?? `call-${callCounter}`);
             const call = {
@@ -341,8 +362,22 @@ async function readCodexSession(transcriptPath) {
             const callId = String(payload.call_id ?? payload.callId ?? '');
             const call = callIndex.get(callId);
             if (call) {
-                call.output = String(payload.output ?? '');
+                const output = String(payload.output ?? '');
+                if (output)
+                    call.output = output;
                 call.endedAt = isoAt;
+                const wallTimeMs = extractWallTimeMs(output);
+                if (wallTimeMs) {
+                    const derivedEndedAt = new Date(parseTimestamp(call.startedAt).getTime() + wallTimeMs).toISOString();
+                    if (parseTimestamp(derivedEndedAt).getTime() > parseTimestamp(call.endedAt).getTime()) {
+                        call.endedAt = derivedEndedAt;
+                    }
+                }
+                if (call.toolName === 'Bash') {
+                    const ptySessionId = extractPtySessionId(output);
+                    if (ptySessionId)
+                        ptyCallBySession.set(ptySessionId, call);
+                }
             }
             continue;
         }
@@ -398,11 +433,12 @@ function remapTurnIds(events, turns) {
 function attachCwdAttribute(events, cwd) {
     if (!cwd)
         return events;
+    const sanitizedCwd = deriveProjectIdFromCwd(cwd);
     return events.map((event) => ({
         ...event,
         attributes: {
             ...(event.attributes ?? {}),
-            'agentic.project.cwd': cwd,
+            'agentic.project.cwd': sanitizedCwd,
         },
     }));
 }

package/dist/runtime/codex/proxy.js

@@ -117,7 +117,10 @@ function correlationKeyFromRequest(req, seq) {
 }
 export function createCodexProxyServer(options) {
     const upstreamBaseUrl = options?.upstreamBaseUrl ?? process.env.OPENAI_BASE_URL ?? 'https://api.openai.com';
-    const spoolDir = options?.spoolDir ?? process.env.SPANORY_CODEX_PROXY_SPOOL_DIR ?? path.join(process.cwd(), '.spanory', 'codex-proxy-spool');
+    const spanoryHome = process.env.SPANORY_HOME ?? path.join(process.env.HOME || '', '.spanory');
+    const spoolDir = options?.spoolDir
+        ?? process.env.SPANORY_CODEX_PROXY_SPOOL_DIR
+        ?? path.join(spanoryHome, 'spool', 'codex-proxy');
     const maxBodyBytes = Number(options?.maxBodyBytes ?? process.env.SPANORY_CODEX_CAPTURE_MAX_BYTES ?? 131072);
     const logger = options?.logger ?? console;
     const upstream = new URL(upstreamBaseUrl);