spexcode 0.6.7 → 0.7.0-next.0

package/node_modules/@spexcode/transcript/dist/readers.js

@@ -0,0 +1,296 @@
+import { execFileSync } from 'node:child_process';
+import { closeSync, openSync, readFileSync, readSync, readdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { TranscriptReadError } from './turns.js';
+import { IntervalCollector, claudeEvent, codexEvent, opencodeEvents, piEvent } from './parsers.js';
+// THE NATIVE-THREAD READERS. Each harness keeps its conversation somewhere private — Claude's project JSONL,
+// Codex's rollout, pi's session JSONL, OpenCode's store behind `opencode export` — and this module is the only
+// place that knows where. It answers exactly one question for every harness: "what happened in this thread
+// between `from` and `to`?", as normalized turns, through the three reader verbs of [[transcript]].
+const POST_RANGE_LOOKAHEAD_LINES = 256;
+const children = (dir) => { try {
+    return readdirSync(dir).sort().reverse();
+}
+catch {
+    return [];
+} };
+// --- where each harness keeps the thread ------------------------------------------------------------------
+const projectTranscriptRoot = () => join(process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude'), 'projects');
+export function claudeTranscriptPath(threadId, root = projectTranscriptRoot()) {
+    for (const project of children(root)) {
+        const path = join(root, project, `${threadId}.jsonl`);
+        try {
+            if (statSync(path).isFile())
+                return path;
+        }
+        catch { /* try next */ }
+    }
+    return null;
+}
+const codexSessionsDir = () => join(process.env.CODEX_HOME || join(homedir(), '.codex'), 'sessions');
+// Walk newest day first and return on the first hit; the walk is exhaustive rather than capped, because
+// future-dated junk under sessions/ sorts above every real day and a cap once masked every real rollout.
+export function codexRolloutPath(threadId, root = codexSessionsDir()) {
+    for (const year of children(root))
+        for (const month of children(join(root, year)))
+            for (const day of children(join(root, year, month))) {
+                const dir = join(root, year, month, day);
+                const file = children(dir).find((name) => name.includes(threadId));
+                if (file)
+                    return join(dir, file);
+            }
+    return null;
+}
+const piSessionsRoot = () => join(process.env.SPEXCODE_PI_AGENT_DIR || join(homedir(), '.pi', 'agent'), 'sessions');
+const piSessionPaths = new Map();
+export function piSessionPath(threadId, root = piSessionsRoot()) {
+    const key = `${root}:${threadId}`;
+    const cached = piSessionPaths.get(key);
+    if (cached) {
+        try {
+            if (statSync(cached).isFile())
+                return cached;
+        }
+        catch {
+            piSessionPaths.delete(key);
+        }
+    }
+    for (const directory of children(root))
+        for (const file of children(join(root, directory))) {
+            if (!file.endsWith('.jsonl'))
+                continue;
+            const path = join(root, directory, file);
+            try {
+                const header = JSON.parse(readFileSync(path, 'utf8').split('\n', 1)[0]);
+                if (header && typeof header === 'object' && header.type === 'session' && header.id === threadId) {
+                    piSessionPaths.set(key, path);
+                    return path;
+                }
+            }
+            catch { /* unreadable entries are not a match */ }
+        }
+    return null;
+}
+const opencodeStoreRoot = () => process.env.SPEXCODE_OPENCODE_DATA_DIR
+    || join(process.env.XDG_DATA_HOME || join(homedir(), '.local', 'share'), 'opencode');
+function opencodeStoreRevision(root) {
+    try {
+        const database = statSync(join(root, 'opencode.db'));
+        let writeAheadLog = '0:0';
+        try {
+            const stat = statSync(join(root, 'opencode.db-wal'));
+            writeAheadLog = `${stat.size}:${Math.floor(stat.mtimeMs)}`;
+        }
+        catch { /* a checkpointed database has no separate write-ahead log */ }
+        return `${database.size}:${Math.floor(database.mtimeMs)}:${writeAheadLog}`;
+    }
+    catch {
+        return null;
+    }
+}
+// The export is read RAW: `--sanitize` replaces every prose and tool-output part with a `[redacted:…]` token,
+// which made the whole conversation unreadable; the reader hands over the same local bytes the other harnesses'
+// files hold, and nothing here leaves the machine that ran the thread.
+function opencodeExport(threadId) {
+    return execFileSync(process.env.SPEXCODE_OPENCODE_CMD || 'opencode', ['export', threadId], {
+        encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
+    });
+}
+const fileRevision = (path) => {
+    try {
+        const stat = statSync(path);
+        return `${stat.size}:${Math.floor(stat.mtimeMs)}`;
+    }
+    catch {
+        return null;
+    }
+};
+// @@@interval-seek - a native file is append-only, so the byte where an interval's first event sits never
+// moves. The open tail re-reads its interval on every change; remembering that offset per (file, from) turns
+// each re-read into "parse the current stretch" instead of "parse the whole thread again".
+const intervalOffsets = new Map();
+// One pass over the bytes from `scan.position` to the end of the file. Every complete line is parsed as JSON
+// and handed to `onLine` with its byte offset; `onLine` returning true stops the scan early (a bounded
+// lookahead), which abandons the rest — only a one-shot read does that.
+function scanLines(harness, fd, scan, onLine) {
+    const chunk = Buffer.allocUnsafe(64 * 1024);
+    let { position, carry } = scan;
+    let lineStart = position - carry.length;
+    while (true) {
+        const read = readSync(fd, chunk, 0, chunk.length, position);
+        if (read <= 0)
+            break;
+        position += read;
+        const buffer = carry.length ? Buffer.concat([carry, chunk.subarray(0, read)]) : Buffer.from(chunk.subarray(0, read));
+        let cut = 0;
+        for (let index = 0; index < buffer.length; index++) {
+            if (buffer[index] !== 10)
+                continue;
+            const line = buffer.subarray(cut, index).toString('utf8');
+            const lineOffset = lineStart;
+            lineStart += index - cut + 1;
+            cut = index + 1;
+            if (!line.trim())
+                continue;
+            let value;
+            try {
+                value = JSON.parse(line);
+            }
+            catch (error) {
+                throw new TranscriptReadError('invalid', `${harness} transcript cannot be parsed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            if (onLine(value, lineOffset))
+                return { position, carry: Buffer.alloc(0) };
+        }
+        carry = Buffer.from(buffer.subarray(cut));
+    }
+    return { position, carry };
+}
+// The cursor over one interval of one line file. A one-shot `read` is a cursor advanced once and dropped; the
+// open interval's `tail` keeps it, so each advance parses only what the harness appended since the last one.
+class LineFileCursor {
+    harness;
+    path;
+    parse;
+    from;
+    collector;
+    scan = { position: 0, carry: Buffer.alloc(0) };
+    started = false;
+    seekKey;
+    constructor(harness, path, parse, from) {
+        this.harness = harness;
+        this.path = path;
+        this.parse = parse;
+        this.from = from;
+        this.seekKey = `${path}\n${from}`;
+        this.collector = new IntervalCollector({ from, to: from });
+    }
+    restart(size) {
+        const seek = intervalOffsets.get(this.seekKey) ?? 0;
+        const start = seek > 0 && seek < size ? seek : 0;
+        this.collector = new IntervalCollector({ from: this.from, to: this.from });
+        // a seek lands on the interval's first event, so the timestamps before it are known to exist
+        if (start > 0)
+            this.collector.sawTimestamp = true;
+        this.scan = { position: start, carry: Buffer.alloc(0) };
+    }
+    advance(to, lookahead = Number.POSITIVE_INFINITY) {
+        let size = 0;
+        try {
+            size = statSync(this.path).size;
+        }
+        catch (error) {
+            throw new TranscriptReadError('unreadable', `${this.harness} transcript is unreadable: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (size <= 0)
+            throw new TranscriptReadError('unreadable', `${this.harness} transcript is unreadable: file is empty`);
+        // a source that shrank was rewritten underneath the cursor: forget the position and read the interval afresh
+        if (!this.started || size < this.scan.position) {
+            this.restart(size);
+            this.started = true;
+        }
+        this.collector.extend(to);
+        let fd = null;
+        try {
+            fd = openSync(this.path, 'r');
+            let postRangeLines = 0;
+            this.scan = scanLines(this.harness, fd, this.scan, (value, offset) => {
+                const event = this.parse(value);
+                if (!event)
+                    return false;
+                const inRange = event.at !== null && event.at >= this.from && event.at <= to;
+                if (inRange && !intervalOffsets.has(this.seekKey))
+                    intervalOffsets.set(this.seekKey, offset);
+                const pastRange = this.collector.add(event);
+                return pastRange && ++postRangeLines >= lookahead;
+            });
+        }
+        catch (error) {
+            if (error instanceof TranscriptReadError)
+                throw error;
+            throw new TranscriptReadError('unreadable', `${this.harness} transcript could not be read: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            if (fd !== null)
+                closeSync(fd);
+        }
+        return this.collector.finish(fileRevision(this.path) ?? `${size}`, this.harness);
+    }
+}
+function lineFileReader(harness, locate, parse) {
+    const find = (threadId) => {
+        const path = locate(threadId);
+        if (!path)
+            throw new TranscriptReadError('missing', `${harness} transcript for ${threadId} is unavailable: file was not found`);
+        return path;
+    };
+    return {
+        revision: (threadId) => { const path = locate(threadId); return path ? fileRevision(path) : null; },
+        // after passing `to`, a one-shot read scans a fixed lookahead window for timestamp disorder before stopping
+        read: async (threadId, range) => new LineFileCursor(harness, find(threadId), parse, range.from).advance(range.to, POST_RANGE_LOOKAHEAD_LINES),
+        tail: (threadId, from) => {
+            let cursor = null;
+            return {
+                // the file is located on the first advance, so a tail opened before the thread exists fails as `missing`
+                // there rather than at construction
+                advance: async (to) => (cursor ??= new LineFileCursor(harness, find(threadId), parse, from)).advance(to),
+                close: () => { cursor = null; },
+            };
+        },
+    };
+}
+export const claudeTranscript = lineFileReader('claude', (threadId) => claudeTranscriptPath(threadId), claudeEvent);
+export const codexTranscript = lineFileReader('codex', (threadId) => codexRolloutPath(threadId), codexEvent);
+export const piTranscript = lineFileReader('pi', (threadId) => piSessionPath(threadId), piEvent);
+// OpenCode has no per-thread file: the store's revision is the change token, and one export per
+// revision is parsed and kept, so repeated interval reads of a quiet thread cost nothing new.
+const opencodeExports = new Map();
+export function opencodeTranscriptReader(root = opencodeStoreRoot(), load = opencodeExport) {
+    const reader = {
+        revision: () => opencodeStoreRevision(root),
+        read: async (threadId, range) => {
+            const revision = opencodeStoreRevision(root);
+            if (!revision)
+                throw new TranscriptReadError('missing', `opencode transcript for ${threadId} is unavailable: store was not found`);
+            const key = `${root}:${threadId}`;
+            let cached = opencodeExports.get(key);
+            if (!cached || cached.revision !== revision) {
+                let exported;
+                try {
+                    exported = load(threadId);
+                }
+                catch (error) {
+                    throw new TranscriptReadError('unreadable', `opencode transcript could not be exported: ${error instanceof Error ? error.message : String(error)}`);
+                }
+                let value;
+                try {
+                    value = JSON.parse(exported);
+                }
+                catch (error) {
+                    throw new TranscriptReadError('invalid', `opencode transcript cannot be parsed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+                cached = { revision, events: opencodeEvents(value) };
+                opencodeExports.set(key, cached);
+            }
+            const collector = new IntervalCollector(range);
+            for (const event of cached.events)
+                collector.add(event);
+            return collector.finish(revision, 'opencode');
+        },
+    };
+    return {
+        ...reader,
+        // no file grows here: an open interval is re-collected from the cached export, which is one export per revision
+        tail: (threadId, from) => ({ advance: (to) => reader.read(threadId, { from, to }), close: () => { } }),
+    };
+}
+export const opencodeTranscript = opencodeTranscriptReader();
+export function unsupportedTranscript(harness) {
+    const refuse = async () => { throw new TranscriptReadError('unsupported', `${harness} does not support transcript access`); };
+    return {
+        revision: () => null,
+        read: refuse,
+        tail: () => ({ advance: refuse, close: () => { } }),
+    };
+}

package/node_modules/@spexcode/transcript/dist/turns.d.ts

@@ -0,0 +1,42 @@
+export type TranscriptRange = Readonly<{
+    from: number;
+    to: number;
+}>;
+export type TranscriptTool = Readonly<{
+    id: string;
+    name: string;
+    input?: string;
+    output?: string;
+    outputLines: number;
+    outputBytes: number;
+}>;
+export type TranscriptTurn = Readonly<{
+    id: string;
+    at: number;
+    role: 'user' | 'assistant';
+    text?: string;
+    tools?: readonly TranscriptTool[];
+}>;
+export type TranscriptRead = Readonly<{
+    revision: string;
+    from: number;
+    to: number;
+    turns: readonly TranscriptTurn[];
+    truncated: boolean;
+    omittedTurns: number;
+    omittedBytes: number;
+    outOfOrderEvents: number;
+}>;
+export type TranscriptTail = Readonly<{
+    advance(to: number): Promise<TranscriptRead>;
+    close(): void;
+}>;
+export type TranscriptReader = Readonly<{
+    revision(threadId: string): string | null;
+    read(threadId: string, range: TranscriptRange): Promise<TranscriptRead>;
+    tail(threadId: string, from: number): TranscriptTail;
+}>;
+export declare class TranscriptReadError extends Error {
+    readonly reason: 'unsupported' | 'missing' | 'unreadable' | 'invalid';
+    constructor(reason: 'unsupported' | 'missing' | 'unreadable' | 'invalid', message: string);
+}

package/node_modules/@spexcode/transcript/dist/turns.js

@@ -0,0 +1,11 @@
+// THE NORMALIZED TRANSCRIPT. Every harness keeps its conversation in a private shape; this is the one shape
+// every surface reads instead: user and assistant prose, tool calls with their input, and each call's output
+// once the harness recorded it. Nothing here imports Node, so a browser renderer and a Node reader share it.
+export class TranscriptReadError extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+        this.name = 'TranscriptReadError';
+    }
+}

package/node_modules/@spexcode/transcript/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@spexcode/transcript",
+  "version": "0.7.0-next.0",
+  "type": "module",
+  "description": "Normalized agent transcripts: one parser per harness, a bounded interval reader over a native thread file or an in-memory event stream, and the full/delta frame protocol every transport and renderer share.",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": "./dist/index.js",
+    "./frames": "./dist/frames.js",
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node ../../scripts/build-dist.mjs",
+    "prepublishOnly": "node ../../scripts/release-publish.mjs --from-package-publish",
+    "test": "npm run build && tsx --import ../../scripts/test-home.mjs --test src/*.test.ts"
+  },
+  "devDependencies": {
+    "@types/node": "^18.19.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.6.3"
+  }
+}

package/node_modules/@vscode/tree-sitter-wasm/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

package/node_modules/@vscode/tree-sitter-wasm/README.md

@@ -0,0 +1,36 @@
+# Pre-built Tree-Sitter wasm files
+
+This repository contains scripts and build pipelines for building the Tree-Sitter and Tree-Sitter grammar WebAssembly files used by VS Code.
+
+## Contributing
+
+This project welcomes contributions and suggestions.  Most contributions require you to agree to a
+Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
+the rights to use your contribution. For details, visit https://cla.opensource.microsoft.com.
+
+When you submit a pull request, a CLA bot will automatically determine whether you need to provide
+a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions
+provided by the bot. You will only need to do this once across all repos using our CLA.
+
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
+For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or
+contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
+
+### Build steps
+
+> Note: If you're using Windows, you'll need to use WSL. Ensure Docker integration for WSL is enabled before attempting to build. Without this integration, the build process may encounter errors.
+
+First, install all of the dependencies using `npm install`, use the `--force` flag if needed. You will also need to install [emscripten](https://emscripten.org/docs/getting_started/downloads.html). 
+
+Then, build the the wasm files using `npm run build-wasm`, which will do the following:
+- Clone the tree-sitter repository
+- Build the tree-sitter WebAssembly bindings
+- Build the tree-sitter grammars listed in https://github.com/microsoft/vscode-tree-sitter-wasm/blob/alexr00/0.0.1/build/main.ts
+
+## Trademarks
+
+This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft 
+trademarks or logos is subject to and must follow 
+[Microsoft's Trademark & Brand Guidelines](https://www.microsoft.com/en-us/legal/intellectualproperty/trademarks/usage/general).
+Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship.
+Any use of third-party trademarks or logos are subject to those third-party's policies.

package/node_modules/@vscode/tree-sitter-wasm/SECURITY.md

@@ -0,0 +1,41 @@
+<!-- BEGIN MICROSOFT SECURITY.MD V0.0.9 BLOCK -->
+
+## Security
+
+Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet) and [Xamarin](https://github.com/xamarin).
+
+If you believe you have found a security vulnerability in any Microsoft-owned repository that meets [Microsoft's definition of a security vulnerability](https://aka.ms/security.md/definition), please report it to us as described below.
+
+## Reporting Security Issues
+
+**Please do not report security vulnerabilities through public GitHub issues.**
+
+Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://aka.ms/security.md/msrc/create-report).
+
+If you prefer to submit without logging in, send email to [secure@microsoft.com](mailto:secure@microsoft.com).  If possible, encrypt your message with our PGP key; please download it from the [Microsoft Security Response Center PGP Key page](https://aka.ms/security.md/msrc/pgp).
+
+You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://www.microsoft.com/msrc). 
+
+Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue:
+
+  * Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.)
+  * Full paths of source file(s) related to the manifestation of the issue
+  * The location of the affected source code (tag/branch/commit or direct URL)
+  * Any special configuration required to reproduce the issue
+  * Step-by-step instructions to reproduce the issue
+  * Proof-of-concept or exploit code (if possible)
+  * Impact of the issue, including how an attacker might exploit the issue
+
+This information will help us triage your report more quickly.
+
+If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://aka.ms/security.md/msrc/bounty) page for more details about our active programs.
+
+## Preferred Languages
+
+We prefer all communications to be in English.
+
+## Policy
+
+Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://aka.ms/security.md/cvd).
+
+<!-- END MICROSOFT SECURITY.MD BLOCK -->

package/node_modules/@vscode/tree-sitter-wasm/cgmanifest.json

@@ -0,0 +1,16 @@
+{
+	"registrations": [
+		{
+			"component": {
+				"type": "git",
+				"git": {
+					"name": "tree-sitter",
+					"repositoryUrl": "https://github.com/tree-sitter/tree-sitter",
+					"commitHash": "fc15f621334a262039ffaded5937e2844f88da61"
+				}
+			},
+			"license": "MIT",
+			"version": "0.25.1"
+		}
+	]
+}

package/node_modules/@vscode/tree-sitter-wasm/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@vscode/tree-sitter-wasm",
+  "version": "0.3.1",
+  "description": "Pre-built WASM files for Tree-Sitter and Tree-Sitter languages that VS Code uses",
+  "scripts": {
+    "build-wasm": "ts-node ./build/main.ts",
+    "install-emsdk": "sudo rm -rf /opt/dev/emsdk && sudo ./build/setup-emsdk.sh"
+  },
+  "author": "Visual Studio Code Team",
+  "license": "MIT",
+  "files": [
+    "wasm",
+    "LICENSE",
+    "README.md",
+    "SECURITY.md",
+    "cgmanifest.json"
+  ],
+  "main": "wasm/tree-sitter.js",
+  "types": "wasm/web-tree-sitter.d.ts",
+  "devDependencies": {
+    "@types/node": "^20.14.6",
+    "tree-sitter-bash": "^0.25.0",
+    "tree-sitter-cli": "^0.25.10",
+    "tree-sitter-css": "^0.25.0",
+    "tree-sitter-go": "^0.25.0",
+    "tree-sitter-java": "^0.23.5",
+    "tree-sitter-javascript": "^0.25.0",
+    "tree-sitter-php": "0.24.2",
+    "tree-sitter-python": "^0.25.0",
+    "tree-sitter-regex": "^0.25.0",
+    "tree-sitter-ruby": "^0.23.1",
+    "tree-sitter-typescript": "^0.23.2",
+    "ts-node": "^10.9.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Microsoft/vscode-tree-sitter-wasm.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Microsoft/vscode-tree-sitter-wasm/issues"
+  }
+}