peaks-loop 4.0.54 → 4.1.1

package/dist/services/context/context-audit-limits.js

@@ -0,0 +1,31 @@
+/**
+ * Size/limit constants and `--top` normalization for `peaks code
+ * context-audit`, moved VERBATIM out of `./context-audit.ts` (wave 3,
+ * eslint-family sweep) so that module stays under the 300 raw-line cap.
+ *
+ * The two transcript-size ceilings keep their exact previous values; they
+ * are written as a named 1 MiB constant times a named Mebibyte count
+ * because the `no-magic-numbers` family flags each factor of a literal
+ * product (`256 * 1024 * 1024`) but not a direct `const` assignment.
+ */
+/** 1 MiB = 1024 × 1024 bytes. */
+const MEBIBYTE = 1048576;
+/** Mebibytes of transcript the audit is still willing to stream (256 MiB). */
+const MAX_TRANSCRIPT_MEBIBYTES = 256;
+/** Default number of top entries emitted. */
+export const CONTEXT_AUDIT_DEFAULT_TOP = 15;
+/** Hard ceiling for `--top` — the envelope must stay small by construction. */
+export const CONTEXT_AUDIT_MAX_TOP = 100;
+/** Transcripts larger than this are reported `available:false` (fail-soft). */
+export const CONTEXT_AUDIT_MAX_TRANSCRIPT_BYTES = MAX_TRANSCRIPT_MEBIBYTES * MEBIBYTE;
+/** Streaming chunk size (bounded memory on multi-MB transcripts) = 1 MiB. */
+export const CONTEXT_AUDIT_SCAN_CHUNK_BYTES = MEBIBYTE;
+/** Clamp a caller-supplied `--top` into the documented range. */
+export function normalizeTopN(value) {
+    const n = typeof value === 'number' && Number.isFinite(value)
+        ? Math.floor(value)
+        : CONTEXT_AUDIT_DEFAULT_TOP;
+    if (n < 1)
+        return CONTEXT_AUDIT_DEFAULT_TOP;
+    return Math.min(n, CONTEXT_AUDIT_MAX_TOP);
+}

package/dist/services/context/context-audit-scan.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Transcript scan + envelope assembly for `peaks code context-audit`.
+ *
+ * Moved out of `./context-audit.ts` (wave 3, eslint-family sweep). The
+ * streaming loop, the fold bookkeeping, the `pctOfTotal` rounding and the
+ * group ordering are the report's contract: every line below is copied
+ * exactly — same predicates, same throw points, same accumulator updates in
+ * the same positions. Only pure sub-blocks whose control flow copies 1:1
+ * were extracted; the read-accumulator loop and the per-line delta
+ * accumulation stay in the functions that own them.
+ */
+import type { ContextAuditResult } from './context-audit-types.js';
+/** Fail-soft envelope: every field zeroed/emptied, only the partial set. */
+export declare function emptyResult(partial: Partial<ContextAuditResult>): ContextAuditResult;
+/**
+ * Stat, size-check and stream a resolved transcript. Fail-soft: every stat
+ * / open / read failure maps to its documented reason via `errorAuditReason`.
+ */
+export declare function auditTranscriptFile(transcriptPath: string, maxBytes: number, topN: number): ContextAuditResult;

package/dist/services/context/context-audit-scan.js

@@ -0,0 +1,246 @@
+/**
+ * Transcript scan + envelope assembly for `peaks code context-audit`.
+ *
+ * Moved out of `./context-audit.ts` (wave 3, eslint-family sweep). The
+ * streaming loop, the fold bookkeeping, the `pctOfTotal` rounding and the
+ * group ordering are the report's contract: every line below is copied
+ * exactly — same predicates, same throw points, same accumulator updates in
+ * the same positions. Only pure sub-blocks whose control flow copies 1:1
+ * were extracted; the read-accumulator loop and the per-line delta
+ * accumulation stay in the functions that own them.
+ */
+import { closeSync, openSync, readSync, statSync } from 'node:fs';
+import { contextAuditKey } from './context-audit-keys.js';
+import { CONTEXT_AUDIT_DEFAULT_TOP, CONTEXT_AUDIT_SCAN_CHUNK_BYTES } from './context-audit-limits.js';
+/** Divisor that renders a ratio as a one-decimal percentage (× 100 / × 10). */
+const ONE_DECIMAL_DIVISOR = 10;
+/** Fail-soft envelope: every field zeroed/emptied, only the partial set. */
+export function emptyResult(partial) {
+    return {
+        available: false,
+        reason: null,
+        transcriptPath: null,
+        totalBytes: 0,
+        entryCount: 0,
+        groupCount: 0,
+        topN: CONTEXT_AUDIT_DEFAULT_TOP,
+        entries: [],
+        ...partial
+    };
+}
+/**
+ * Map an `auditTranscriptFile` failure to its machine-readable
+ * unavailability reason. Same ENOENT / EACCES+EPERM / other ternary chain
+ * and reason strings as before the move.
+ */
+function errorAuditReason(err) {
+    const code = err.code;
+    return code === 'ENOENT'
+        ? 'transcript-not-found'
+        : code === 'EACCES' || code === 'EPERM'
+            ? 'transcript-unreadable'
+            : 'audit-failed';
+}
+/** UTF-8 size of a JSON value that survived neither the string nor array path. */
+function jsonBytes(value) {
+    try {
+        return Buffer.byteLength(JSON.stringify(value) ?? '', 'utf8');
+    }
+    catch {
+        return 0;
+    }
+}
+/** Byte size of one `tool_result.content` array element (same fall-through). */
+function contentPartBytes(part) {
+    if (typeof part === 'string') {
+        return Buffer.byteLength(part, 'utf8');
+    }
+    if (typeof part === 'object' && part !== null) {
+        const text = part.text;
+        return typeof text === 'string'
+            ? Buffer.byteLength(text, 'utf8')
+            : Buffer.byteLength(JSON.stringify(part) ?? '', 'utf8');
+    }
+    return 0;
+}
+/** UTF-8 size of a `tool_result.content` payload (string | array | object). */
+function toolResultBytes(content) {
+    if (typeof content === 'string')
+        return Buffer.byteLength(content, 'utf8');
+    if (Array.isArray(content)) {
+        let total = 0;
+        for (const part of content) {
+            total += contentPartBytes(part);
+        }
+        return total;
+    }
+    if (content === undefined || content === null)
+        return 0;
+    return jsonBytes(content);
+}
+/** Pull `message.content` out of a parsed record; `null` when shape differs. */
+function extractMessageContent(parsed) {
+    if (typeof parsed !== 'object' || parsed === null)
+        return null;
+    const record = parsed;
+    const message = record.message;
+    if (typeof message !== 'object' || message === null)
+        return null;
+    const content = message.content;
+    if (!Array.isArray(content))
+        return null;
+    return content;
+}
+function rememberToolUse(item, toolUses) {
+    const id = item.id;
+    const name = item.name;
+    if (typeof id === 'string' && typeof name === 'string') {
+        toolUses.set(id, { name, input: item.input });
+    }
+}
+/** Fold one `tool_result` part into its group; returns the byte delta. */
+function addToolResult(item, toolUses, groups) {
+    const ref = typeof item.tool_use_id === 'string' ? toolUses.get(item.tool_use_id) : undefined;
+    const tool = ref?.name ?? 'unknown';
+    const key = ref === undefined ? '' : contextAuditKey(tool, ref.input);
+    const size = toolResultBytes(item.content);
+    const groupKey = `${tool} ${key}`;
+    const group = groups.get(groupKey);
+    if (group === undefined) {
+        groups.set(groupKey, { tool, key, bytes: size, count: 1 });
+    }
+    else {
+        group.bytes += size;
+        group.count += 1;
+    }
+    return size;
+}
+/**
+ * Fold ONE jsonl line into the running state. Returns the byte/count delta
+ * contributed by this line. Corrupt / non-JSON lines are skipped silently —
+ * a truncated tail must not fail the audit.
+ */
+function foldLine(line, toolUses, groups) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return { bytes: 0, count: 0 };
+    }
+    const content = extractMessageContent(parsed);
+    if (content === null)
+        return { bytes: 0, count: 0 };
+    let bytes = 0;
+    let count = 0;
+    for (const part of content) {
+        if (typeof part !== 'object' || part === null)
+            continue;
+        const item = part;
+        if (item.type === 'tool_use') {
+            rememberToolUse(item, toolUses);
+            continue;
+        }
+        if (item.type !== 'tool_result')
+            continue;
+        const size = addToolResult(item, toolUses, groups);
+        bytes += size;
+        count += 1;
+    }
+    return { bytes, count };
+}
+/** Percentage in [0, 100], one decimal — see ContextAuditEntry.pctOfTotal. */
+function percentOfTotal(bytes, totalBytes) {
+    return totalBytes > 0 ? Math.round((bytes / totalBytes) * 1000) / ONE_DECIMAL_DIVISOR : 0;
+}
+/** Group → entries, sorted by bytes descending (ties: tool, then key). */
+function rankGroups(groups, totalBytes) {
+    const entries = [...groups]
+        .map((g) => ({
+        tool: g.tool,
+        key: g.key,
+        bytes: g.bytes,
+        pctOfTotal: percentOfTotal(g.bytes, totalBytes),
+        count: g.count
+    }))
+        .sort((a, b) => b.bytes - a.bytes || a.tool.localeCompare(b.tool) || a.key.localeCompare(b.key));
+    return entries;
+}
+/**
+ * Stream the transcript once, folding every tool result into its
+ * `(tool, key)` group. Pure bookkeeping — no content is retained.
+ */
+function streamTranscript(filePath, toolUses, groups) {
+    let totalBytes = 0;
+    let entryCount = 0;
+    const fd = openSync(filePath, 'r');
+    try {
+        const size = statSync(filePath).size;
+        let position = 0;
+        let carry = '';
+        while (position < size) {
+            const readLen = Math.min(CONTEXT_AUDIT_SCAN_CHUNK_BYTES, size - position);
+            const buf = Buffer.alloc(readLen);
+            const bytesRead = readSync(fd, buf, 0, readLen, position);
+            if (bytesRead <= 0)
+                break;
+            position += bytesRead;
+            const lines = (carry + buf.toString('utf8', 0, bytesRead)).split('\n');
+            // The last element is a partial line (or the trailing empty string).
+            carry = lines.pop() ?? '';
+            for (const line of lines) {
+                if (line.length === 0)
+                    continue;
+                const folded = foldLine(line, toolUses, groups);
+                totalBytes += folded.bytes;
+                entryCount += folded.count;
+            }
+        }
+        if (carry.length > 0) {
+            const folded = foldLine(carry, toolUses, groups);
+            totalBytes += folded.bytes;
+            entryCount += folded.count;
+        }
+    }
+    finally {
+        try {
+            closeSync(fd);
+        }
+        catch {
+            /* best-effort close */
+        }
+    }
+    return { totalBytes, entryCount };
+}
+function scanTranscript(filePath, topN) {
+    const toolUses = new Map();
+    const groups = new Map();
+    const totals = streamTranscript(filePath, toolUses, groups);
+    const entries = rankGroups(groups.values(), totals.totalBytes);
+    return {
+        available: true,
+        reason: null,
+        transcriptPath: filePath,
+        totalBytes: totals.totalBytes,
+        entryCount: totals.entryCount,
+        groupCount: entries.length,
+        topN,
+        entries: entries.slice(0, topN)
+    };
+}
+/**
+ * Stat, size-check and stream a resolved transcript. Fail-soft: every stat
+ * / open / read failure maps to its documented reason via `errorAuditReason`.
+ */
+export function auditTranscriptFile(transcriptPath, maxBytes, topN) {
+    try {
+        const size = statSync(transcriptPath).size;
+        if (size > maxBytes) {
+            return emptyResult({ reason: 'transcript-too-large', transcriptPath, topN });
+        }
+        return scanTranscript(transcriptPath, topN);
+    }
+    catch (err) {
+        return emptyResult({ reason: errorAuditReason(err), transcriptPath, topN });
+    }
+}

package/dist/services/context/context-audit-types.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Public envelope types for `peaks code context-audit`, plus the two
+ * module-internal shapes shared by the scan/fold machinery.
+ *
+ * Moved VERBATIM out of `./context-audit.ts` (wave 3, eslint-family sweep)
+ * so that module stays under the 300 raw-line cap. Mechanical move only —
+ * field order, optionality and doc comments are unchanged; the three public
+ * interfaces are re-exported from `./context-audit.ts` unchanged.
+ */
+export interface ContextAuditEntry {
+    /** Tool name (`Bash`, `Read`, `Grep`, …), or `unknown` when unmatched. */
+    readonly tool: string;
+    /** Short, stable summary of the tool input (command line / path tail / pattern). */
+    readonly key: string;
+    /** Total UTF-8 bytes of every tool result in this group. */
+    readonly bytes: number;
+    /**
+     * Share of the session's tool-result bytes, as a PERCENTAGE in `[0, 100]`
+     * with one decimal (e.g. `4.2` — not the `0.042` ratio). The name and the
+     * value agree: `pct` means percent.
+     */
+    readonly pctOfTotal: number;
+    /** How many tool results landed in this group. */
+    readonly count: number;
+}
+export interface ContextAuditResult {
+    /** False when the transcript could not be read; see `reason`. */
+    readonly available: boolean;
+    /** Machine-readable unavailability reason (`null` when available). */
+    readonly reason: string | null;
+    /** Absolute transcript path, or `null` when unresolved. */
+    readonly transcriptPath: string | null;
+    /** Total UTF-8 bytes of all tool results seen. */
+    readonly totalBytes: number;
+    /** Number of tool-result entries seen. */
+    readonly entryCount: number;
+    /** Distinct `(tool, key)` groups — always ≥ `entries.length`. */
+    readonly groupCount: number;
+    /** Number of top entries requested. */
+    readonly topN: number;
+    /** Top-N groups, sorted by bytes descending. */
+    readonly entries: readonly ContextAuditEntry[];
+}
+export interface ContextAuditInput {
+    /** Outer (harness) session id — the transcript is named by it. */
+    readonly outerSessionId?: string | null;
+    /** How many top entries to emit. Clamped to `[1, CONTEXT_AUDIT_MAX_TOP]`. */
+    readonly topN?: number;
+    /** Explicit transcript path override (test seam; skips the locator). */
+    readonly transcriptPath?: string | null;
+    /** Override the too-large threshold (test seam; default 256 MB). */
+    readonly maxTranscriptBytes?: number;
+    /** Env used to detect the active IDE (default `process.env`). */
+    readonly env?: NodeJS.ProcessEnv;
+}
+export interface ToolUseRef {
+    readonly name: string;
+    readonly input: unknown;
+}
+export interface MutableGroup {
+    readonly tool: string;
+    readonly key: string;
+    bytes: number;
+    count: number;
+}

package/dist/services/context/context-audit-types.js

@@ -0,0 +1,10 @@
+/**
+ * Public envelope types for `peaks code context-audit`, plus the two
+ * module-internal shapes shared by the scan/fold machinery.
+ *
+ * Moved VERBATIM out of `./context-audit.ts` (wave 3, eslint-family sweep)
+ * so that module stays under the 300 raw-line cap. Mechanical move only —
+ * field order, optionality and doc comments are unchanged; the three public
+ * interfaces are re-exported from `./context-audit.ts` unchanged.
+ */
+export {};

package/dist/services/context/context-audit.d.ts

@@ -25,66 +25,20 @@
  * summary* of the tool input — the Bash command line, the file path tail, the
  * grep pattern — so "4 × the same 40KB reindex dump" collapses into ONE row
  * with `count: 4` instead of four anonymous entries.
+ *
+ * Split note (wave 3, eslint-family sweep): the public envelope types live
+ * in `./context-audit-types.ts`, the limits constants and `--top` clamp in
+ * `./context-audit-limits.ts`, the group-key builders in
+ * `./context-audit-keys.ts`, and the streaming scan / fold / ranking /
+ * fail-soft assembly in `./context-audit-scan.ts`. Those bodies were moved
+ * VERBATIM — control flow copied, nothing improved — so this module keeps
+ * its whole public surface (every name re-exported below) and stays under
+ * the 300 raw-line cap.
  */
-/** Default number of top entries emitted. */
-export declare const CONTEXT_AUDIT_DEFAULT_TOP = 15;
-/** Hard ceiling for `--top` — the envelope must stay small by construction. */
-export declare const CONTEXT_AUDIT_MAX_TOP = 100;
-/** Transcripts larger than this are reported `available:false` (fail-soft). */
-export declare const CONTEXT_AUDIT_MAX_TRANSCRIPT_BYTES: number;
-export interface ContextAuditEntry {
-    /** Tool name (`Bash`, `Read`, `Grep`, …), or `unknown` when unmatched. */
-    readonly tool: string;
-    /** Short, stable summary of the tool input (command line / path tail / pattern). */
-    readonly key: string;
-    /** Total UTF-8 bytes of every tool result in this group. */
-    readonly bytes: number;
-    /**
-     * Share of the session's tool-result bytes, as a PERCENTAGE in `[0, 100]`
-     * with one decimal (e.g. `4.2` — not the `0.042` ratio). The name and the
-     * value agree: `pct` means percent.
-     */
-    readonly pctOfTotal: number;
-    /** How many tool results landed in this group. */
-    readonly count: number;
-}
-export interface ContextAuditResult {
-    /** False when the transcript could not be read; see `reason`. */
-    readonly available: boolean;
-    /** Machine-readable unavailability reason (`null` when available). */
-    readonly reason: string | null;
-    /** Absolute transcript path, or `null` when unresolved. */
-    readonly transcriptPath: string | null;
-    /** Total UTF-8 bytes of all tool results seen. */
-    readonly totalBytes: number;
-    /** Number of tool-result entries seen. */
-    readonly entryCount: number;
-    /** Distinct `(tool, key)` groups — always ≥ `entries.length`. */
-    readonly groupCount: number;
-    /** Number of top entries requested. */
-    readonly topN: number;
-    /** Top-N groups, sorted by bytes descending. */
-    readonly entries: readonly ContextAuditEntry[];
-}
-export interface ContextAuditInput {
-    /** Outer (harness) session id — the transcript is named by it. */
-    readonly outerSessionId?: string | null;
-    /** How many top entries to emit. Clamped to `[1, CONTEXT_AUDIT_MAX_TOP]`. */
-    readonly topN?: number;
-    /** Explicit transcript path override (test seam; skips the locator). */
-    readonly transcriptPath?: string | null;
-    /** Override the too-large threshold (test seam; default 256 MB). */
-    readonly maxTranscriptBytes?: number;
-    /** Env used to detect the active IDE (default `process.env`). */
-    readonly env?: NodeJS.ProcessEnv;
-}
-/** Clamp a caller-supplied `--top` into the documented range. */
-export declare function normalizeTopN(value: unknown): number;
-/**
- * Build the stable group key for one tool call. Unknown tools fall back to a
- * clipped JSON rendering of their input so the group is still recognizable.
- */
-export declare function contextAuditKey(tool: string, input: unknown): string;
+import type { ContextAuditInput, ContextAuditResult } from './context-audit-types.js';
+export { CONTEXT_AUDIT_DEFAULT_TOP, CONTEXT_AUDIT_MAX_TOP, CONTEXT_AUDIT_MAX_TRANSCRIPT_BYTES, normalizeTopN } from './context-audit-limits.js';
+export { contextAuditKey } from './context-audit-keys.js';
+export type { ContextAuditEntry, ContextAuditInput, ContextAuditResult } from './context-audit-types.js';
 /**
  * Audit the CURRENT session's transcript. Never throws.
  *