spexcode 0.6.7 → 0.7.0-next.0

package/node_modules/@spexcode/session-core/dist/session-timeline.js

@@ -1,216 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { existsSync, readFileSync, appendFileSync, mkdirSync, statSync, readdirSync, openSync, closeSync, readSync } from 'node:fs';
-import { basename, join } from 'node:path';
-import { sessionStoreDir, sessionArtifactPath } from '@spexcode/spec-core';
-const timelinePath = (id) => sessionArtifactPath(id, 'timeline.ndjson');
-const segmentsDir = (id) => sessionArtifactPath(id, 'timeline');
-const SEGMENT = /^(\d+)\.ndjson$/;
-const SEGMENT_NAME_WIDTH = 12;
-const TAIL_BLOCK_BYTES = 64 * 1024;
-// One logical timeline is legacy timeline.ndjson followed by immutable numbered segments. The directory
-// listing is its only index: numbering is append order, so there is no mutable manifest to repair.
-function segmentFiles(id) {
-    try {
-        const dir = segmentsDir(id);
-        const names = readdirSync(dir).filter((name) => SEGMENT.test(name)).sort((a, b) => {
-            const an = BigInt(SEGMENT.exec(a)[1]), bn = BigInt(SEGMENT.exec(b)[1]);
-            return an < bn ? -1 : an > bn ? 1 : 0;
-        });
-        return names.map((name) => join(dir, name));
-    }
-    catch { /* no numbered segments yet */ }
-    return [];
-}
-function timelineFiles(id) {
-    const files = [];
-    const legacy = timelinePath(id);
-    if (existsSync(legacy))
-        files.push(legacy);
-    files.push(...segmentFiles(id));
-    return files;
-}
-const segmentLimit = () => {
-    const configured = Number(process.env.SPEXCODE_TIMELINE_SEGMENT_BYTES);
-    return Number.isFinite(configured) ? Math.max(1024, Math.floor(configured)) : 4 * 1024 * 1024;
-};
-function activeSegment(id, bytes) {
-    const dir = segmentsDir(id);
-    mkdirSync(dir, { recursive: true });
-    const segments = segmentFiles(id);
-    const current = segments.at(-1);
-    if (!current)
-        return join(dir, `${String(1).padStart(SEGMENT_NAME_WIDTH, '0')}.ndjson`);
-    try {
-        if (statSync(current).size === 0 || statSync(current).size + bytes <= segmentLimit())
-            return current;
-    }
-    catch { /* a vanished active segment is recreated under its next number */ }
-    const n = BigInt(SEGMENT.exec(basename(current))[1]) + 1n;
-    return join(dir, `${String(n).padStart(SEGMENT_NAME_WIDTH, '0')}.ndjson`);
-}
-function append(id, ev) {
-    mkdirSync(sessionStoreDir(id), { recursive: true });
-    const line = JSON.stringify(ev) + '\n';
-    appendFileSync(activeSegment(id, Buffer.byteLength(line)), line);
-}
-function parseLines(lines) {
-    return lines.map((l) => {
-        try {
-            return JSON.parse(l);
-        }
-        catch {
-            return null;
-        }
-    }).filter((e) => e != null && (e.kind === 'status' || e.kind === 'sent' || e.kind === 'dispatch-settled'));
-}
-function tailPublicEvents(path, limit) {
-    let fd = null;
-    try {
-        const size = statSync(path).size;
-        fd = openSync(path, 'r');
-        let start = size;
-        let text = '';
-        while (start > 0) {
-            const next = Math.max(0, start - TAIL_BLOCK_BYTES);
-            const buf = Buffer.alloc(start - next);
-            readSync(fd, buf, 0, buf.length, next);
-            text = buf.toString('utf8') + text;
-            const publicCount = parseLines(text.split('\n').filter(Boolean)).filter((event) => event.kind !== 'dispatch-settled').length;
-            if (publicCount >= limit || next === 0)
-                break;
-            start = next;
-        }
-        return parseLines(text.split('\n').filter(Boolean))
-            .filter((event) => event.kind !== 'dispatch-settled')
-            .slice(-limit);
-    }
-    catch {
-        return [];
-    }
-    finally {
-        if (fd !== null)
-            closeSync(fd);
-    }
-}
-// Record a lifecycle value that has already landed in session.json. TypeScript state writers call this
-// synchronously before returning, so a later write cannot erase an intermediate declaration note from the
-// conversation. Best-effort: history is an accessory to the state machine, and failing to write it must never
-// break the transition that already happened.
-export function recordStatus(id, status, proposal, note) {
-    try {
-        append(id, { ts: new Date().toISOString(), kind: 'status', status, proposal, note });
-    }
-    catch { /* the record already moved; the history line is the only loss */ }
-}
-// The DELIVERY ([[dispatch]]): appending this line IS the send, so unlike a status line it must fail LOUD —
-// the caller reports the throw rather than a false success. `text` is the message BEFORE any mechanism insert
-// (hints are transport, not conversation); `replyVia` is the effective channel the prompt seam chose. Returns
-// the new line's `mid`, which a best-effort poke carries.
-export function appendSent(id, text, from, replyVia, dispatchReceipt) {
-    const mid = randomUUID();
-    append(id, { ts: new Date().toISOString(), kind: 'sent', mid, text, from, ...(replyVia ? { replyVia } : {}), ...(dispatchReceipt ? { dispatchReceipt } : {}) });
-    return { mid };
-}
-export function sentDispatchReceipt(id, operation, requestDigest) {
-    let found = null;
-    const settled = new Set();
-    for (const path of timelineFiles(id)) {
-        for (const event of parseLines(readFileSync(path, 'utf8').split('\n').filter(Boolean))) {
-            if (event.kind === 'sent' && !found && event.dispatchReceipt?.operation === operation && event.dispatchReceipt.requestDigest === requestDigest) {
-                found = { mid: event.mid, payloadHash: event.dispatchReceipt.payloadHash, delivery: event.dispatchReceipt.delivery ?? null };
-            }
-            else if (event.kind === 'dispatch-settled' && event.operation === operation && event.requestDigest === requestDigest) {
-                settled.add(event.mid);
-            }
-        }
-    }
-    return found ? { ...found, delivered: settled.has(found.mid) } : null;
-}
-export function settleSentDispatch(id, mid) {
-    let receipt = null;
-    let settled = false;
-    for (const path of timelineFiles(id)) {
-        for (const event of parseLines(readFileSync(path, 'utf8').split('\n').filter(Boolean))) {
-            if (event.kind === 'sent' && event.mid === mid && event.dispatchReceipt?.delivery)
-                receipt = event.dispatchReceipt;
-            if (event.kind === 'dispatch-settled' && event.mid === mid)
-                settled = true;
-        }
-    }
-    if (!receipt || settled)
-        return;
-    append(id, { ts: new Date().toISOString(), kind: 'dispatch-settled', operation: receipt.operation, requestDigest: receipt.requestDigest, mid });
-}
-// The unowned read: any process may take it with nothing but filesystem access, and taking it perturbs
-// nothing. Index = event position, which is what a cursor names ([[session-cursors]]).
-export function timelineEvents(id) {
-    try {
-        return timelineFiles(id).flatMap((path) => parseLines(readFileSync(path, 'utf8').split('\n').filter(Boolean)))
-            .flatMap((stored) => {
-            if (stored.kind === 'dispatch-settled')
-                return [];
-            if (stored.kind === 'status')
-                return [stored];
-            const { dispatchReceipt: _receipt, ...event } = stored;
-            return [event];
-        });
-    }
-    catch {
-        return [];
-    }
-}
-// the same L0 read taken as CHEAPLY as it can be: a follower ([[session-follow]]) ticks over many logs, so it
-// stats first and parses only what grew. null = no log yet (a session that has authored nothing).
-export function timelineStamp(id) {
-    try {
-        const path = timelineFiles(id).at(-1);
-        if (!path)
-            return null;
-        const s = statSync(path);
-        return `${path}:${s.size}:${s.mtimeMs}`;
-    }
-    catch {
-        return null;
-    }
-}
-// the channel of the LAST HUMAN send (from == null): 'note' when the note-reply hint rode along, else null.
-// This is what makes the reply-channel hints SYMMETRIC ([[session-timeline]]): a human send with no note flag
-// arriving after a note-send is the "back at a terminal" transition, and the delivery gets the counter-insert.
-// Derived from the durable log — no new state, and it survives a server restart. Agent senders (`from` set)
-// say nothing about where the HUMAN is reading, so they neither set nor clear it.
-export function lastHumanSendVia(id) {
-    const evs = timelineEvents(id);
-    for (let i = evs.length - 1; i >= 0; i--) {
-        const e = evs[i];
-        if (e.kind === 'sent' && e.from == null)
-            return e.replyVia === 'note' ? 'note' : null;
-    }
-    return null;
-}
-export function currentHumanTurn(id) {
-    const evs = timelineEvents(id);
-    for (let i = evs.length - 1; i >= 0; i--) {
-        const e = evs[i];
-        if (e.kind === 'sent' && e.from == null)
-            return { token: e.mid, acceptedAt: e.ts };
-    }
-    return null;
-}
-// Durable tail read with no board/governance policy. A runtime that owns a compatible session directory can
-// consume the same protocol; product surfaces decide separately whether that id is visible to them.
-export function timelineTail(id, limit = 500) {
-    const wanted = Math.max(1, limit);
-    const tail = [];
-    for (const path of timelineFiles(id).reverse()) {
-        const remaining = wanted - tail.length;
-        if (remaining <= 0)
-            break;
-        tail.unshift(...tailPublicEvents(path, remaining));
-    }
-    return tail.map((e) => {
-        if (e.kind === 'status')
-            return e;
-        const { dispatchReceipt: _receipt, ...event } = e;
-        return event;
-    });
-}

package/node_modules/@spexcode/spec-cli/dist/execution-trace.d.ts

@@ -1,26 +0,0 @@
-export type ExecutionTurn = Readonly<{
-    token: string;
-    acceptedAt: string;
-}>;
-export type ExecutionStepKind = 'command' | 'read' | 'write' | 'search' | 'tool';
-export type ExecutionStep = Readonly<{
-    id: string;
-    kind: ExecutionStepKind;
-    label: string;
-    detail?: string;
-    state: 'running' | 'done';
-}>;
-export type ExecutionTrace = Readonly<{
-    revision: string;
-    turnId: string | null;
-    workingNote: string | null;
-    steps: readonly ExecutionStep[];
-}>;
-type ExportLoader = (threadId: string) => string;
-export declare function codexRolloutPath(threadId: string, root?: string): string | null;
-export declare function readCodexExecutionTrace(threadId: string, turn: ExecutionTurn | null, root?: string): ExecutionTrace;
-export declare function readProjectJsonlExecutionTrace(threadId: string, turn: ExecutionTurn | null, root?: string): ExecutionTrace;
-export declare function readSessionJsonlExecutionTrace(threadId: string, turn: ExecutionTurn | null, root?: string): ExecutionTrace;
-export declare function readLocalStoreExecutionTrace(threadId: string, turn: ExecutionTurn | null, root?: string, load?: ExportLoader): ExecutionTrace;
-export declare const noExecutionTrace: (_threadId: string, _turn: ExecutionTurn | null) => ExecutionTrace | null;
-export {};