@1agents/session-reader 0.1.1

package/dist/src/distiller.js

@@ -0,0 +1,122 @@
+import path from 'node:path';
+import { isInside } from './util/paths.js';
+import { clip, oneLine } from './util/text.js';
+import { fileWrites, rawCommand, resolveWritePath } from './writes.js';
+/** Paths a tool call wrote to, including files written through the shell. */
+export function editedFiles(turn, workspace) {
+    return fileWrites(turn).map((write) => resolveWritePath(write, workspace));
+}
+export function shellCommand(turn) {
+    const command = rawCommand(turn);
+    return command ? oneLine(command, 200) : undefined;
+}
+function relativize(file, workspace) {
+    return workspace && isInside(workspace, file) ? path.relative(workspace, file) || '.' : file;
+}
+function collectTurningPoints(turns) {
+    const points = [];
+    const users = turns.filter((t) => t.kind === 'user' && t.text?.trim());
+    users.forEach((turn, i) => {
+        points.push({
+            timestamp: turn.timestamp,
+            kind: i === 0 ? 'request' : 'redirect',
+            text: oneLine(turn.text, 220),
+        });
+    });
+    for (const turn of turns.filter((t) => t.kind === 'tool_result' && t.isError).slice(0, 5)) {
+        points.push({ timestamp: turn.timestamp, kind: 'failure', text: oneLine(turn.toolResult, 200) });
+    }
+    const final = [...turns].reverse().find((t) => t.kind === 'assistant' && t.text?.trim());
+    if (final) {
+        points.push({ timestamp: final.timestamp, kind: 'outcome', text: oneLine(final.text, 300) });
+    }
+    return points.sort((a, b) => Date.parse(a.timestamp ?? '') - Date.parse(b.timestamp ?? ''));
+}
+function bullets(items, max) {
+    const shown = items.slice(0, max).map((item) => `- ${item}`);
+    if (items.length > max)
+        shown.push(`- …另有 ${items.length - max} 项`);
+    return shown.length ? shown.join('\n') : '- （无）';
+}
+const KIND_LABEL = {
+    request: '需求',
+    redirect: '转向',
+    failure: '受阻',
+    outcome: '结论',
+};
+function render(digest, turns, focus) {
+    const { session, goal, touchedFiles, commands, turningPoints, artifacts } = digest;
+    const head = [
+        `# ${session.title ?? session.id}`,
+        '',
+        `- 智能体：${session.provider}　会话：\`${session.id}\``,
+        `- 工作区：${session.workspace ?? '未知'}`,
+        `- 时间：${session.createdAt ?? '?'} → ${session.updatedAt ?? '?'}`,
+        `- 规模：${turns.length} 轮事件，改动 ${touchedFiles.length} 个文件，执行 ${commands.length} 条命令`,
+        '',
+        '## 目标',
+        '',
+        goal || '（未能识别）',
+        '',
+    ];
+    const files = ['## 改动的文件', '', bullets(touchedFiles, 25), ''];
+    const points = [
+        '## 关键节点',
+        '',
+        turningPoints.length
+            ? turningPoints
+                .slice(0, 10)
+                .map((p) => `- **${KIND_LABEL[p.kind]}**：${p.text}`)
+                .join('\n')
+            : '- （无）',
+        '',
+    ];
+    const artifactSection = artifacts.length
+        ? ['## 产出物', '', bullets(artifacts.map((a) => `${a.name} — ${a.path}`), 10), '']
+        : [];
+    if (focus === 'marketing') {
+        const highlights = turningPoints.filter((p) => p.kind !== 'request').slice(0, 6);
+        return [
+            ...head,
+            '## 亮点',
+            '',
+            highlights.length ? highlights.map((p) => `- ${KIND_LABEL[p.kind]}：${p.text}`).join('\n') : '- （无）',
+            '',
+            ...files,
+            ...artifactSection,
+        ].join('\n');
+    }
+    const body = [...head, ...files, '## 执行的命令', '', bullets(commands, 15), '', ...points, ...artifactSection];
+    if (focus === 'review')
+        return body.join('\n');
+    const skeleton = turns
+        .map((turn) => {
+        const label = turn.toolName ? `${turn.kind}(${turn.toolName})` : turn.kind;
+        return `${String(turn.index).padStart(3, ' ')} ${label}: ${oneLine(turn.text ?? turn.toolResult, 110)}`;
+    })
+        .slice(0, 120);
+    return [...body, '## 轮次骨架', '', '```', ...skeleton, '```', ''].join('\n');
+}
+export function distillSession(session, options = {}) {
+    const focus = options.focus ?? 'review';
+    const workspace = session.ref.workspace;
+    const touched = new Set();
+    const commands = [];
+    for (const turn of session.turns) {
+        for (const file of editedFiles(turn, workspace))
+            touched.add(relativize(file, workspace));
+        const command = shellCommand(turn);
+        if (command && !commands.includes(command))
+            commands.push(command);
+    }
+    const firstUser = session.turns.find((t) => t.kind === 'user' && t.text?.trim());
+    const digest = {
+        session: session.ref,
+        goal: clip(firstUser?.text, focus === 'full' ? 1200 : 400),
+        touchedFiles: [...touched].sort(),
+        commands,
+        turningPoints: collectTurningPoints(session.turns),
+        artifacts: session.artifacts,
+    };
+    return { ...digest, markdown: render(digest, session.turns, focus) };
+}

package/dist/src/index.d.ts

@@ -0,0 +1,19 @@
+export type { AgentProvider, BackgroundTask, DigestFocus, FileChange, FileTouch, GitCommit, ProviderStats, SessionOverview, SessionStats, TokenUsage, AsyncJob, CommandRecord, FactSource, FileGroup, FileRecord, Provenance, JobStatus, TurnDetail, TurnStatus, TurnSummary, UserTurnKind, UserTurnNote, NormalizedSession, SessionArtifact, SessionDigest, SessionRef, TurnEvent, TurnKind, TurningPoint, UnifiedTimelineEntry, WorkspaceDigest, } from './types.js';
+export { adapters, findResolvedByWorkspace, loadSession, type LoadOptions, findSessionsByWorkspace, listRecentSessions, listResolvedSessions, parseSession, parseSince, resolveSession, type ListOptions, type ResolvedSession, } from './resolver.js';
+export { distillSession, editedFiles, shellCommand } from './distiller.js';
+export { buildOverview } from './overview.js';
+export { classifyUserTurn } from './classify.js';
+export { commandLedger, displayPath, errorLedger, fileLedger, jobCounts, jobLedger, } from './ledger.js';
+export { eventDetail, summarizeTurns, turnDetail, type EventDetail } from './turns.js';
+export { analyzableCommand, fileWrites, rawCommand, stripHeredocs, resolveWritePath, type FileWrite, } from './writes.js';
+export { mandatoryLiteral, planQuery, searchSessions, type QueryPlan, type SearchHit, type SearchMatch, type SearchOptions, } from './search.js';
+export { aggregateWorkspaceSessions, type AggregateOptions } from './aggregator.js';
+export type { ProviderAdapter, SessionCandidate } from './parsers/provider.js';
+export { canonicalizePath, isInside, slugifyWorkspace } from './util/paths.js';
+export { defaultDbPath, openStore, resetStoreCache } from './store/db.js';
+export { indexSession, refreshSession, type IndexAction, type IndexOptions, type IndexResult, type RefreshResult, } from './store/indexer.js';
+export { searchRows, type RowQuery, type TextRow } from './store/rows.js';
+export { findSessionRow, readSession, sessionRow, type SessionRow } from './store/read.js';
+export { captureRuntimeEdge, deriveEdges, edgeEvidence, edgesOf, invocationsOf, type EdgeRelation, type EdgeView, } from './store/edges.js';
+export { deriveFacts } from './store/facts.js';
+export { EDGE_VERSION, EXTRACTOR_VERSION, PARSER_VERSION, SCHEMA_VERSION, } from './store/schema.js';

package/dist/src/index.js

@@ -0,0 +1,17 @@
+export { adapters, findResolvedByWorkspace, loadSession, findSessionsByWorkspace, listRecentSessions, listResolvedSessions, parseSession, parseSince, resolveSession, } from './resolver.js';
+export { distillSession, editedFiles, shellCommand } from './distiller.js';
+export { buildOverview } from './overview.js';
+export { classifyUserTurn } from './classify.js';
+export { commandLedger, displayPath, errorLedger, fileLedger, jobCounts, jobLedger, } from './ledger.js';
+export { eventDetail, summarizeTurns, turnDetail } from './turns.js';
+export { analyzableCommand, fileWrites, rawCommand, stripHeredocs, resolveWritePath, } from './writes.js';
+export { mandatoryLiteral, planQuery, searchSessions, } from './search.js';
+export { aggregateWorkspaceSessions } from './aggregator.js';
+export { canonicalizePath, isInside, slugifyWorkspace } from './util/paths.js';
+export { defaultDbPath, openStore, resetStoreCache } from './store/db.js';
+export { indexSession, refreshSession, } from './store/indexer.js';
+export { searchRows } from './store/rows.js';
+export { findSessionRow, readSession, sessionRow } from './store/read.js';
+export { captureRuntimeEdge, deriveEdges, edgeEvidence, edgesOf, invocationsOf, } from './store/edges.js';
+export { deriveFacts } from './store/facts.js';
+export { EDGE_VERSION, EXTRACTOR_VERSION, PARSER_VERSION, SCHEMA_VERSION, } from './store/schema.js';

package/dist/src/ledger.d.ts

@@ -0,0 +1,19 @@
+import type { AsyncJob, CommandRecord, FileRecord, JobStatus, NormalizedSession } from './types.js';
+/**
+ * Every shell command with whatever is known about how it went. Codex records
+ * this itself; for the others we pair each call with the result that follows.
+ */
+export declare function commandLedger(session: NormalizedSession): CommandRecord[];
+/**
+ * Failed commands, plus whether a similar command later succeeded.
+ * A command counts as failed only on a non-zero exit, or on an unknown exit
+ * that the provider itself flagged — never merely because stderr had content.
+ */
+export declare function errorLedger(session: NormalizedSession): CommandRecord[];
+/** Background jobs, merged from provider receipts, shell launches and pids. */
+export declare function jobLedger(session: NormalizedSession): AsyncJob[];
+export declare function jobCounts(jobs: AsyncJob[]): Record<JobStatus, number>;
+/** Every file the session wrote, bucketed by what kind of file it is. */
+export declare function fileLedger(session: NormalizedSession): FileRecord[];
+/** Display helper shared by the CLI: workspace-relative when possible. */
+export declare function displayPath(record: FileRecord, workspace: string | undefined): string;

package/dist/src/ledger.js

@@ -0,0 +1,192 @@
+import path from 'node:path';
+import { isInside } from './util/paths.js';
+import { oneLine } from './util/text.js';
+import { analyzableCommand, fileWrites, rawCommand, resolveWritePath } from './writes.js';
+import { summarizeTurns } from './turns.js';
+const SSH_HOST = /\b[\w.-]+@((?:\d{1,3}(?:\.\d{1,3}){3})|(?:[\w-]+(?:\.[\w-]+)+))/;
+const BACKGROUND = /\b(?:nohup|setsid|start_new_session\s*=\s*True|subprocess\.Popen|Popen\(|queue-[\w-]+\.py)\b/;
+const LOG_PATH = /([\w./-]+\.log)\b/;
+const PID_ECHO = /\b(?:pid|PID)[\s=:]+(\d{2,7})\b/;
+const LOG_FILE = /(?:\.log|\.download\.log)$|progress\.jsonl?$/i;
+const TEMP_DIR = /^\/(?:private\/)?(?:tmp|var\/folders)\//;
+/** Maps each event index to the turn it belongs to. */
+function turnOf(session) {
+    const ranges = summarizeTurns(session).map((turn) => turn.events);
+    return (index) => {
+        const found = ranges.findIndex(([start, end]) => index >= start && index <= end);
+        return found === -1 ? 0 : found + 1;
+    };
+}
+/**
+ * Every shell command with whatever is known about how it went. Codex records
+ * this itself; for the others we pair each call with the result that follows.
+ */
+export function commandLedger(session) {
+    const toTurn = turnOf(session);
+    if (session.stats.commands.length) {
+        // Codex keeps its own ledger; align it with the event stream by order.
+        const callIndexes = session.turns.filter((event) => rawCommand(event)).map((event) => event.index);
+        return session.stats.commands.map((record, i) => {
+            const eventIndex = callIndexes[i] ?? -1;
+            return { ...record, eventIndex, turn: eventIndex >= 0 ? toTurn(eventIndex) : 0 };
+        });
+    }
+    const records = [];
+    for (const event of session.turns) {
+        const command = rawCommand(event);
+        if (!command)
+            continue;
+        // The next tool_result is this command's outcome.
+        const result = session.turns
+            .slice(event.index + 1, event.index + 4)
+            .find((candidate) => candidate.kind === 'tool_result');
+        const host = SSH_HOST.exec(command)?.[1];
+        records.push({
+            eventIndex: event.index,
+            turn: toTurn(event.index),
+            command: oneLine(command, 300),
+            provenance: 'derived',
+            extractor: 'pair:tool_call+tool_result',
+            ...(host ? { host } : {}),
+            ...(event.timestamp ? { timestamp: event.timestamp } : {}),
+            // An explicit status wins; otherwise "provider did not flag an error"
+            // is itself the provider's verdict, not a guess of ours.
+            ...(result?.exitCode !== undefined
+                ? { exitCode: result.exitCode }
+                : result && result.isError === false
+                    ? { exitCode: 0 }
+                    : {}),
+            ...(result?.durationMs !== undefined ? { durationMs: result.durationMs } : {}),
+            ...(result?.isError && result.toolResult ? { stderr: oneLine(result.toolResult, 300) } : {}),
+        });
+    }
+    return records;
+}
+/**
+ * Failed commands, plus whether a similar command later succeeded.
+ * A command counts as failed only on a non-zero exit, or on an unknown exit
+ * that the provider itself flagged — never merely because stderr had content.
+ */
+export function errorLedger(session) {
+    const commands = commandLedger(session);
+    const failed = commands.filter((record) => (record.exitCode !== undefined && record.exitCode !== 0) || (record.exitCode === undefined && record.stderr));
+    const prefix = (command) => command.split(/\s+/).slice(0, 3).join(' ');
+    return failed.map((record) => ({
+        ...record,
+        laterSucceeded: commands.some((other) => other.eventIndex > record.eventIndex &&
+            other.exitCode === 0 &&
+            prefix(other.command) === prefix(record.command)),
+    }));
+}
+/** Background jobs, merged from provider receipts, shell launches and pids. */
+export function jobLedger(session) {
+    const jobs = new Map();
+    for (const task of session.stats.backgroundTasks) {
+        jobs.set(task.id, {
+            id: task.id,
+            ...(task.title ? { command: task.title } : {}),
+            ...(task.log ? { log: task.log } : {}),
+            provenance: 'observed',
+            extractor: 'receipt:messages',
+            status: task.finished ? 'completed' : 'unknown',
+            evidence: task.finished ? ['provider 有完成回执'] : ['provider 记录了任务，但没有完成回执'],
+        });
+    }
+    for (const event of session.turns) {
+        const command = analyzableCommand(event);
+        if (!command || !BACKGROUND.test(command))
+            continue;
+        const segment = command.split(/[\n;]|&&/).find((part) => BACKGROUND.test(part)) ?? command;
+        const log = LOG_PATH.exec(segment)?.[1] ?? LOG_PATH.exec(command)?.[1];
+        const id = log ?? `event-${event.index}`;
+        if (jobs.has(id))
+            continue;
+        const host = SSH_HOST.exec(command)?.[1];
+        jobs.set(id, {
+            id,
+            command: oneLine(segment, 200),
+            ...(log ? { log } : {}),
+            ...(host ? { host } : {}),
+            ...(event.timestamp ? { startedAt: event.timestamp } : {}),
+            discoveredFrom: event.index,
+            provenance: 'derived',
+            extractor: 'shell:background-launch',
+            // No receipt, no claim: we only saw it start.
+            status: 'unknown',
+            evidence: [`事件 #${event.index} 启动了后台进程，会话内未见结束证据`],
+        });
+    }
+    // A pid printed back by the shell is the only in-band proof a job existed.
+    for (const event of session.turns) {
+        if (event.kind !== 'tool_result')
+            continue;
+        const pid = PID_ECHO.exec(event.toolResult ?? '')?.[1];
+        if (!pid)
+            continue;
+        const nearest = [...jobs.values()].find((job) => job.discoveredFrom !== undefined && Math.abs(job.discoveredFrom - event.index) <= 2 && !job.pid);
+        if (nearest) {
+            nearest.pid = pid;
+            nearest.evidence.push(`结果里回显了 pid ${pid}`);
+        }
+    }
+    return [...jobs.values()];
+}
+export function jobCounts(jobs) {
+    const counts = { completed: 0, failed: 0, running: 0, unknown: 0 };
+    for (const job of jobs)
+        counts[job.status]++;
+    return counts;
+}
+function groupOf(fullPath, host, workspace) {
+    if (LOG_FILE.test(fullPath) || TEMP_DIR.test(fullPath))
+        return 'log';
+    if (host)
+        return 'runtime';
+    return workspace && isInside(workspace, fullPath) ? 'project' : 'runtime';
+}
+/** Every file the session wrote, bucketed by what kind of file it is. */
+export function fileLedger(session) {
+    const toTurn = turnOf(session);
+    const workspace = session.ref.workspace;
+    const records = new Map();
+    for (const event of session.turns) {
+        for (const write of fileWrites(event)) {
+            const filePath = write.host ? write.path : resolveWritePath(write, workspace);
+            const key = `${write.host ?? ''}|${filePath}`;
+            if (records.has(key))
+                continue;
+            records.set(key, {
+                path: filePath,
+                ...(write.host ? { host: write.host } : {}),
+                operation: write.extractor.split(':').pop() ?? write.extractor,
+                turn: toTurn(event.index),
+                eventIndex: event.index,
+                ...(event.timestamp ? { timestamp: event.timestamp } : {}),
+                provenance: write.provenance,
+                extractor: write.extractor,
+                group: groupOf(filePath, write.host, workspace),
+            });
+        }
+    }
+    for (const change of session.stats.fileChanges) {
+        const key = `|${change.path}`;
+        if (records.has(key))
+            continue;
+        records.set(key, {
+            path: change.path,
+            operation: change.change,
+            turn: 0,
+            eventIndex: -1,
+            provenance: 'observed',
+            extractor: 'item:FileChange',
+            group: groupOf(change.path, undefined, workspace),
+        });
+    }
+    return [...records.values()];
+}
+/** Display helper shared by the CLI: workspace-relative when possible. */
+export function displayPath(record, workspace) {
+    if (record.host)
+        return `${record.host}:${record.path}`;
+    return workspace && isInside(workspace, record.path) ? path.relative(workspace, record.path) : record.path;
+}

package/dist/src/overview.d.ts

@@ -0,0 +1,6 @@
+import type { NormalizedSession, SessionOverview } from './types.js';
+/**
+ * Tier one of the three-level view: everything about a session that is worth
+ * knowing before deciding which turn to open.
+ */
+export declare function buildOverview(session: NormalizedSession): SessionOverview;