@phnx-labs/agents-cli 1.22.120 → 1.22.121

package/dist/lib/session/linear.js

@@ -1,99 +0,0 @@
-/**
- * Resolve a clickable Linear issue URL for a tracker key (e.g. `RUSH-1234`).
- *
- * Linear issue URLs are workspace-scoped — `https://linear.app/<workspace>/issue/<KEY>`
- * — so a bare key can't be linked without knowing the workspace slug (Linear's
- * `organization.urlKey`). That slug is resolved config-first, never hardcoded:
- *
- *   1. `LINEAR_WORKSPACE` env var — explicit override, else
- *   2. `workspaceUrlKey` in the linear-cli config (`~/.linear-cli/config.json`).
- *
- * When neither is set the ticket stays plain text — it's still shown, just not
- * linked. This keeps the published CLI free of any Rush/workspace-specific string.
- */
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-/** A Linear tracker key: `TEAM-N`, e.g. `RUSH-1234`. Mirrors the detector's shape. */
-const LINEAR_KEY_RE = /^[A-Z]{2,6}-\d{1,6}$/;
-/**
- * The same key, matched inside free text on word boundaries. Uppercase-only team
- * key (2–6 letters) so a lowercase `utf-8` can't masquerade as a ticket. Global
- * so {@link linearIssueKeys} can pull every mention out of a body.
- */
-const LINEAR_KEY_IN_TEXT_RE = /\b([A-Z]{2,6}-\d{1,6})\b/g;
-/**
- * Team prefixes that match the key shape but are not trackers — unit strings and
- * common acronyms. Canonical here (the Linear module) so both the URL linkifier
- * and the session-transcript ticket detector (`detectTicket` in `state.ts`) agree
- * on what is a real key rather than each keeping its own copy.
- */
-export const LINEAR_KEY_DENYLIST = new Set([
-    'UTF',
-    'SHA',
-    'ISO',
-    'RFC',
-    'IPV',
-    'X86',
-    'ARM',
-    'MP',
-    'H',
-]);
-/**
- * Every distinct real Linear key mentioned in free text, in first-seen order.
- * Honours {@link LINEAR_KEY_DENYLIST} so `UTF-8` / `X86-64` never count. Used to
- * linkify ticket ids an owner ping only names in prose (no `session.ticketId`).
- */
-export function linearIssueKeys(text) {
-    if (!text)
-        return [];
-    const seen = new Set();
-    const keys = [];
-    for (const m of text.matchAll(LINEAR_KEY_IN_TEXT_RE)) {
-        const key = m[1];
-        if (LINEAR_KEY_DENYLIST.has(key.split('-')[0]))
-            continue;
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        keys.push(key);
-    }
-    return keys;
-}
-// `undefined` = not yet resolved; `null` = resolved-but-unknown (skip re-reading).
-let workspaceCache;
-/** The configured Linear workspace slug, or undefined when unknown. Cached per process. */
-export function linearWorkspace() {
-    if (workspaceCache !== undefined)
-        return workspaceCache ?? undefined;
-    const env = process.env.LINEAR_WORKSPACE?.trim();
-    if (env) {
-        workspaceCache = env;
-        return env;
-    }
-    try {
-        const cfgPath = path.join(os.homedir(), '.linear-cli', 'config.json');
-        const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
-        const ws = cfg.workspaceUrlKey?.trim();
-        if (ws) {
-            workspaceCache = ws;
-            return ws;
-        }
-    }
-    catch {
-        // no linear-cli config (or unreadable) — leave tickets unlinked
-    }
-    workspaceCache = null;
-    return undefined;
-}
-/** Canonical Linear issue URL for a tracker key, or undefined if unresolvable. */
-export function linearIssueUrl(ticketId) {
-    if (!ticketId || !LINEAR_KEY_RE.test(ticketId))
-        return undefined;
-    const ws = linearWorkspace();
-    return ws ? `https://linear.app/${ws}/issue/${ticketId}` : undefined;
-}
-/** Clear the cached workspace lookup. Tests only. */
-export function _resetLinearWorkspaceCache() {
-    workspaceCache = undefined;
-}

package/dist/lib/session/parse.d.ts

@@ -1,224 +0,0 @@
-/**
- * Session file parsers for Claude, Codex, Gemini, and OpenCode.
- *
- * Each agent stores sessions in a different format (JSONL, JSON, SQLite).
- * This module normalizes all of them into a flat array of SessionEvent
- * objects suitable for rendering, filtering, and summarization.
- */
-import type { SessionAgentId, SessionEvent } from './types.js';
-/**
- * Largest session file we will load into memory. Above this we throw a clean
- * error instead of OOMing or hitting V8's ERR_STRING_TOO_LONG. Aligns with
- * Node's ~512MB string ceiling with a healthy margin.
- */
-export declare const SESSION_FILE_MAX_BYTES = 200000000;
-/**
- * Strip terminal control sequences that a malicious session file could use to
- * hijack the user's terminal (clipboard via OSC 52, scrollback wipe, alt-screen
- * takeover, cursor moves, etc.). Allowed through: tab (0x09), newline (0x0a),
- * carriage return (0x0d). Everything else in the C0/C1 range and every CSI/OSC
- * escape is dropped.
- */
-export { sanitizeForTerminal } from '../redact.js';
-/** In-place sanitize every user-visible string field on a list of events. */
-export declare function sanitizeEvents(events: SessionEvent[]): void;
-/**
- * Read a session file, refusing files above maxBytes. Bounded read protects
- * against multi-GB session blobs that would OOM the CLI or exceed V8's
- * ERR_STRING_TOO_LONG ceiling.
- */
-export declare function safeReadSessionFile(filePath: string, maxBytes?: number): string;
-export interface ParseSessionOptions {
-    /** Keep normalized tool results compact by default; renderers can request full output. */
-    maxToolOutputChars?: number;
-    /** Opt-in because interrupts are not user messages and would change the published event stream. */
-    includeInterrupts?: boolean;
-    /**
-     * Opt-in `file_change` events from the harness's own file ledger (Claude
-     * `file-history-delta`). Opt-in for the same reason as
-     * {@link includeInterrupts}: they are not tool calls, and emitting them by
-     * default would change every published event stream (message counts, digests,
-     * trajectories) for a signal only the timeline fold consumes.
-     */
-    includeFileHistory?: boolean;
-}
-export declare function parseSession(filePath: string, agent?: SessionAgentId, opts?: ParseSessionOptions): SessionEvent[];
-/** Infer the agent type from a session file path using known directory conventions. */
-export declare function detectAgent(filePath: string): SessionAgentId | null;
-/**
- * Checklist-snapshot tool names across harnesses — each sends the WHOLE list on
- * every write, so the last call is the current checklist. Claude `TodoWrite`,
- * Kimi `TodoList`, Droid/OpenCode `todo_write`, Codex `update_plan`.
- */
-export declare const SNAPSHOT_TODO_TOOLS: Set<string>;
-/**
- * Whether a harness's checklist status means "finished". Claude/Codex write
- * `completed`; Kimi writes `done`.
- */
-export declare function isCompletedTodoStatus(status: unknown): boolean;
-/**
- * Summarize a tool_use into a one-liner string.
- */
-export declare function summarizeToolUse(tool: string, args?: Record<string, any>): string;
-/** Parse a Claude JSONL session file into normalized events. */
-export declare function parseClaude(filePath: string, opts?: ParseSessionOptions): SessionEvent[];
-/**
- * Parse Claude JSONL *content* (already read into a string) into normalized
- * events. Split from `parseClaude` so the tail reader can parse just the last
- * chunk of a file without re-reading the whole thing. Malformed leading lines
- * (a tail that starts mid-line) are skipped by the per-line try/catch below.
- */
-export declare function parseClaudeContent(content: string, opts?: ParseSessionOptions): SessionEvent[];
-/** Parse a Codex JSONL session file into normalized events. */
-export declare function parseCodex(filePath: string): SessionEvent[];
-export declare function applyPatchTargetPaths(input: string): string[];
-/**
- * Codex writes its turn TWICE in one rollout: the raw `response_item` records
- * the model exchanged, and a parallel `event_msg` / `item_completed` stream of
- * typed, already-classified items. The two overlap — on a 6,244-line rollout on
- * zion (2026-09-06) the same turn appears as 648 `custom_tool_call` +
- * 60 `function_call` records AND as 1,038 `CommandExecution` items — so the two
- * MUST NOT be merged into one event list: every consumer that counts tool calls
- * (digest, trajectory, insights, the tool index) would double-count.
- *
- * {@link parseCodexContent} therefore keeps reading `response_item` and this is
- * a SEPARATE reader over the item stream, for consumers that want the harness's
- * own classification instead of re-deriving it: the command as Codex parsed it
- * (`parsed_cmd.type`), its `exit_code`/`status`, the per-path `FileChange`
- * ledger, `AgentMessage.phase` (`commentary` is the narration between calls),
- * web searches, sub-agent activity and compactions. The timeline fold is the
- * consumer; `parseSession` is untouched.
- *
- * Version-tolerant by construction: an item type this does not know folds to a
- * generic `other` tool_use rather than throwing, so a Codex release that adds an
- * item type degrades to a counted step instead of an empty timeline.
- */
-export declare function parseCodexItemsContent(content: string): SessionEvent[];
-/**
- * Parse Codex JSONL *content* (already read into a string) into normalized
- * events. Split from `parseCodex` so the tail reader can parse just the last
- * chunk without re-reading the whole file.
- */
-export declare function parseCodexContent(content: string): SessionEvent[];
-/**
- * Parse an Antigravity conversation SQLite DB into normalized tool_use events.
- * Deduped by the tool-call id so each tool appears once (Antigravity writes a
- * request step and a completion step that share the id).
- */
-export declare function parseAntigravity(dbPath: string): SessionEvent[];
-/**
- * Split a stored session `file_path` into its on-disk container and the optional
- * in-container fragment. For a plain per-session file the container is the path
- * itself and `fragment` is undefined; for a composite path it is the part before
- * the first `#` and the id after it.
- */
-export declare function splitSessionFilePath(filePath: string): {
-    container: string;
-    fragment: string | undefined;
-};
-/**
- * The filesystem path whose existence/stat decides whether a session row is
- * stale. For a composite `file_path` this is the CONTAINER file — the row is a
- * record inside it, never a filesystem entry of its own — so a composite session
- * is stale only when its container is gone. For a plain path it is the path
- * itself. Keying off the composite FORM (a `#` fragment), not any harness name,
- * means any future single-file-DB harness inherits the correct behavior.
- */
-export declare function sessionFilePathContainer(filePath: string): string;
-/**
- * Parse an OpenCode session from its SQLite database.
- * filePath format: "/path/to/opencode.db#session_id"
- *
- * Data model: session -> message -> part
- * Messages have role (user/assistant) and metadata.
- * Parts contain the actual content: text, tool, reasoning, patch, step-start/finish.
- */
-/**
- * Parse a Grok (xAI CLI) session into normalized events.
- *
- * A Grok session dir holds several files; the conversation transcript is
- * `chat_history.jsonl`, one JSON object per line with a `type`:
- *   - `system`       — the system prompt (skipped; not conversational)
- *   - `user`         — `content` is an array of `{ type: 'text', text }` blocks
- *   - `assistant`    — `content` is a string, plus a `tool_calls[]` array of
- *                      `{ id, name, arguments }` (arguments is a JSON string)
- *   - `reasoning`    — chain-of-thought; text (when present) lives in `summary`
- *   - `tool_result`  — `{ tool_call_id, content }`, correlated back to the call
- *
- * The scanner records `summary.json` as the session's filePath (see
- * `readGrokMeta` in discover.ts), so resolve `chat_history.jsonl` from the same
- * dir; also accept being handed the transcript file directly. Per-line
- * timestamps aren't stored, so every event carries the session's `created_at`
- * (from summary.json), falling back to the transcript's mtime.
- */
-/**
- * Counters Grok writes beside its transcript in `signals.json` — the only place
- * a Grok session records milestones and failures, since `chat_history.jsonl`
- * carries no timestamps and no exit codes. Read by the timeline fold to mark a
- * session that committed / opened / merged a PR and to report a tool-failure
- * count the event stream cannot supply.
- */
-interface GrokSessionSignals {
-    gitCommitCount: number;
-    prCreatedCount: number;
-    prMergedCount: number;
-    toolFailureCount: number;
-}
-/**
- * Read `signals.json` next to a Grok transcript. Returns `undefined` when the
- * file is absent or unreadable — a Grok session simply has no signals then, and
- * the fold reports what it does have rather than inventing zeros.
- */
-export declare function readGrokSignals(filePath: string): GrokSessionSignals | undefined;
-export declare function parseGrok(filePath: string): SessionEvent[];
-/**
- * The transcript query {@link parseOpenCode} runs, exported so a test can assert
- * the projection's real cost against a database instead of re-typing the SQL.
- *
- * A tool part is PROJECTED to exactly the fields the `case 'tool'` branch below
- * reads — `tool`, `callID`, `state.status`, `state.input`, `state.output` —
- * rather than carried whole. Two things this has to get right at once:
- *
- *   - Keep `state.input`. It carries `filePath` / `command`, and losing it is
- *     what left `recentDirectoriesTouched` empty (RUSH-2358).
- *   - Stay bounded. A tool part is not bounded by its output: on a real
- *     `opencode.db` the largest part is 1,346,068 bytes of which
- *     `state.attachments` (a base64 data URL from `read`) is 1,345,674, while
- *     `state.output` is 23. Truncating only `state.output` therefore bounded
- *     nothing — it took one session's loaded tool payload from 299,365 to
- *     1,911,209 bytes. The projection drops `attachments` (and every other
- *     unread key) outright, caps `state.output`, and collapses an oversized
- *     `state.input` to just its addressing fields. Those are the keys the
- *     enrichment reads — `filePath`/`path` for an edit and `cwd`/`workdir`/
- *     `working_directory` for a shell (`extractRecentDirectoriesTouched` in
- *     state.ts), plus `command`/`description`, themselves capped since a command
- *     can be arbitrarily long. Above the cap every other input key (an `edit`'s
- *     `oldString`/`newString`) is gone, deliberately — nothing downstream reads
- *     them, and they are the weight.
- *
- * `json_valid` guards every `json_extract`: SQLite raises "malformed JSON" on a
- * non-JSON value, which aborts the WHOLE query, so one bad `part` row would
- * otherwise cost the entire transcript. Note the single-argument form is
- * RFC-8259-strict — it rejects a JSONB blob that `json_extract` would accept.
- * That is correct for today's schema (`part.data` / `message.data` are TEXT on
- * a real database); if OpenCode ever migrates them to JSONB, these guards must
- * move to `json_valid(data, 6)` or they will drop every row.
- *
- * The session id is bound as a parameter; the two caps are numeric literals.
- */
-export declare const OPENCODE_TRANSCRIPT_QUERY: string;
-export declare function parseOpenCode(filePath: string): SessionEvent[];
-export declare function parseOpencodeCloud(filePath: string): SessionEvent[];
-/** Parse a Rush JSONL session file into normalized events. */
-export declare function parseRush(filePath: string): SessionEvent[];
-/** Parse a Kimi session state.json file by reading its agents/main/wire.jsonl. */
-export declare function parseKimi(filePath: string): SessionEvent[];
-/** Parse Cursor's Anthropic-shaped message JSONL transcript. */
-export declare function parseCursor(filePath: string): SessionEvent[];
-/**
- * Parse a Droid (Factory) JSONL session file into normalized events. Droid
- * wraps each turn in a `{type:'message', message:{role, content, modelId}}`
- * envelope; the content blocks are Anthropic-shaped (text/thinking/tool_use/
- * tool_result), so block handling mirrors the Claude parser.
- */
-export declare function parseDroid(filePath: string): SessionEvent[];