@shepai/cli 1.180.0 → 1.181.0-pr539.0993dc0

package/dist/packages/core/src/infrastructure/services/subprocess-filter/filters/shared-helpers.js

@@ -0,0 +1,85 @@
+/**
+ * Shared helpers used across all subprocess output filters.
+ *
+ * These are small, pure functions for text transformation —
+ * deduplication, blank-line collapsing, ANSI stripping, and
+ * middle-truncation. Each filter composes from these primitives.
+ */
+/**
+ * Strip ANSI escape sequences (colors, cursor movement, etc.).
+ * Covers standard SGR sequences: \x1b[0;31m, \x1b[1m, etc.
+ */
+// eslint-disable-next-line no-control-regex
+const ANSI_REGEX = /\x1b\[[0-9;]*[a-zA-Z]/g;
+export function stripAnsi(text) {
+    return text.replace(ANSI_REGEX, '');
+}
+/**
+ * Collapse runs of 3+ consecutive blank lines into a single blank line.
+ * Trims trailing whitespace from each line as a side effect.
+ */
+export function collapseBlankLines(text) {
+    const lines = text.split('\n');
+    const result = [];
+    let consecutiveBlanks = 0;
+    for (const line of lines) {
+        const trimmed = line.trimEnd();
+        if (trimmed.length === 0) {
+            consecutiveBlanks++;
+            if (consecutiveBlanks <= 2) {
+                result.push('');
+            }
+        }
+        else {
+            consecutiveBlanks = 0;
+            result.push(trimmed);
+        }
+    }
+    return result.join('\n');
+}
+/**
+ * Deduplicate consecutive identical lines, appending a count.
+ *
+ * Example:
+ *   "ok\nok\nok\nfail" → "ok (×3)\nfail"
+ */
+export function deduplicateLines(text) {
+    const lines = text.split('\n');
+    if (lines.length === 0)
+        return text;
+    const result = [];
+    let prevLine = lines[0];
+    let count = 1;
+    for (let i = 1; i < lines.length; i++) {
+        if (lines[i] === prevLine) {
+            count++;
+        }
+        else {
+            result.push(count > 1 ? `${prevLine} (×${count})` : prevLine);
+            prevLine = lines[i];
+            count = 1;
+        }
+    }
+    result.push(count > 1 ? `${prevLine} (×${count})` : prevLine);
+    return result.join('\n');
+}
+/**
+ * Truncate text that exceeds maxLines by keeping the top half and
+ * bottom quarter, inserting an omission marker in the middle.
+ *
+ * Preserves the head (most likely context/setup) and tail (most
+ * likely summary/errors) which are the parts LLMs benefit from most.
+ */
+export function truncateMiddle(text, maxLines) {
+    const lines = text.split('\n');
+    if (lines.length <= maxLines)
+        return text;
+    const keepTop = Math.ceil(maxLines * 0.6);
+    const keepBottom = maxLines - keepTop - 1;
+    const omitted = lines.length - keepTop - keepBottom;
+    return [
+        ...lines.slice(0, keepTop),
+        `... ${omitted} lines omitted ...`,
+        ...lines.slice(lines.length - keepBottom),
+    ].join('\n');
+}

package/dist/packages/core/src/infrastructure/services/subprocess-filter/shep-filter.d.ts

@@ -0,0 +1,27 @@
+/**
+ * shep-filter — tiny CLI entry point for subprocess output filtering.
+ *
+ * Invoked by PATH-shadow wrapper scripts inside the Claude Code
+ * subprocess:
+ *
+ *   shep-filter git status --porcelain
+ *   shep-filter npm test
+ *
+ * Flow:
+ * 1. Parse args to extract the real command name and its arguments
+ * 2. Spawn the real command (resolved from PATH, skipping our shim dir)
+ * 3. Capture stdout + stderr
+ * 4. Pipe stdout through the appropriate filter
+ * 5. Print filtered stdout, pass stderr through, exit with the child's code
+ *
+ * On any filter error: emit raw stdout unchanged (fail-open).
+ */
+/**
+ * Run the filter pipeline. Exported for testing; the CLI entry point
+ * at the bottom of this file calls this with `process.argv`.
+ */
+export declare function runFilter(argv: string[], env: NodeJS.ProcessEnv): {
+    stdout: string;
+    exitCode: number;
+};
+//# sourceMappingURL=shep-filter.d.ts.map

package/dist/packages/core/src/infrastructure/services/subprocess-filter/shep-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shep-filter.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/subprocess-filter/shep-filter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAeH;;;GAGG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EAAE,EACd,GAAG,EAAE,MAAM,CAAC,UAAU,GACrB;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAgDtC"}

package/dist/packages/core/src/infrastructure/services/subprocess-filter/shep-filter.js

@@ -0,0 +1,89 @@
+/**
+ * shep-filter — tiny CLI entry point for subprocess output filtering.
+ *
+ * Invoked by PATH-shadow wrapper scripts inside the Claude Code
+ * subprocess:
+ *
+ *   shep-filter git status --porcelain
+ *   shep-filter npm test
+ *
+ * Flow:
+ * 1. Parse args to extract the real command name and its arguments
+ * 2. Spawn the real command (resolved from PATH, skipping our shim dir)
+ * 3. Capture stdout + stderr
+ * 4. Pipe stdout through the appropriate filter
+ * 5. Print filtered stdout, pass stderr through, exit with the child's code
+ *
+ * On any filter error: emit raw stdout unchanged (fail-open).
+ */
+import { execFileSync } from 'node:child_process';
+import { filterGit } from './filters/git-filter.js';
+import { filterNpm } from './filters/npm-filter.js';
+import { filterGeneric } from './filters/generic-filter.js';
+/** Dispatch table: command name → filter function(subcommand, output). */
+const FILTERS = {
+    git: filterGit,
+    npm: filterNpm,
+    pnpm: filterNpm,
+    yarn: filterNpm,
+};
+/**
+ * Run the filter pipeline. Exported for testing; the CLI entry point
+ * at the bottom of this file calls this with `process.argv`.
+ */
+export function runFilter(argv, env) {
+    // argv: [node, shep-filter.js, <command>, <subcommand?>, ...args]
+    const command = argv[2];
+    const subcommand = argv[3] ?? '';
+    const childArgs = argv.slice(3);
+    if (!command) {
+        return { stdout: '', exitCode: 1 };
+    }
+    // Resolve the REAL binary by stripping our shim dir from PATH.
+    // The shim dir is passed via SHEP_FILTER_SHIM_DIR env var so we
+    // know which PATH entry to skip.
+    const shimDir = env.SHEP_FILTER_SHIM_DIR ?? '';
+    const realPath = (env.PATH ?? '')
+        .split(':')
+        .filter((p) => p !== shimDir)
+        .join(':');
+    let rawStdout;
+    let exitCode;
+    try {
+        rawStdout = execFileSync(command, childArgs, {
+            encoding: 'utf-8',
+            env: { ...env, PATH: realPath },
+            stdio: ['inherit', 'pipe', 'inherit'],
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        exitCode = 0;
+    }
+    catch (err) {
+        // execFileSync throws on non-zero exit. Extract output + code.
+        const execErr = err;
+        rawStdout = typeof execErr.stdout === 'string' ? execErr.stdout : '';
+        exitCode = typeof execErr.status === 'number' ? execErr.status : 1;
+        // On error, preserve full output — errors must never be filtered.
+        return { stdout: rawStdout, exitCode };
+    }
+    // Apply the filter (fail-open: if the filter crashes, emit raw).
+    try {
+        const filterFn = FILTERS[command];
+        const filtered = filterFn ? filterFn(subcommand, rawStdout) : filterGeneric(rawStdout);
+        return { stdout: filtered, exitCode };
+    }
+    catch {
+        return { stdout: rawStdout, exitCode };
+    }
+}
+// --- CLI entry point ---
+// Only runs when this file is the main module (not when imported for testing).
+const isMainModule = typeof process !== 'undefined' &&
+    process.argv[1] &&
+    (process.argv[1].endsWith('shep-filter.js') || process.argv[1].endsWith('shep-filter.ts'));
+if (isMainModule) {
+    const { stdout, exitCode } = runFilter(process.argv, process.env);
+    if (stdout)
+        process.stdout.write(stdout);
+    process.exit(exitCode);
+}

package/dist/packages/core/src/infrastructure/services/subprocess-filter/shim-generator.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Shim generator — creates a per-worker temp directory containing
+ * wrapper scripts that shadow real commands (git, npm, pnpm, yarn)
+ * and pipe their output through shep-filter.
+ *
+ * The temp directory is prepended to PATH in the subprocess env so
+ * that when Claude Code's Bash tool runs `git status`, it hits our
+ * wrapper first. The wrapper:
+ *
+ * 1. Sets SHEP_FILTER_SHIM_DIR so shep-filter can skip our dir when
+ *    resolving the real binary
+ * 2. Calls `node <path-to-shep-filter.js> <command> "$@"`
+ * 3. Exits with shep-filter's exit code
+ *
+ * On macOS/Linux the wrappers are bash scripts with +x.
+ * On Windows they are .cmd files (not yet implemented — TODO).
+ */
+export interface ShimDirectory {
+    /** Absolute path to the temp directory containing the shim scripts. */
+    path: string;
+    /** The commands that have shims in this directory. */
+    commands: readonly string[];
+}
+/**
+ * Create a temp directory with shim scripts for all supported commands.
+ *
+ * @param shepFilterPath - Absolute path to the compiled shep-filter.js
+ * @returns The shim directory info needed for PATH prepending
+ */
+export declare function createShimDirectory(shepFilterPath: string): ShimDirectory;
+/**
+ * Build a modified PATH string with the shim directory prepended.
+ *
+ * @param shimDir - The shim directory path
+ * @param originalPath - The original PATH from the environment
+ * @returns The new PATH value with shimDir first
+ */
+export declare function buildFilteredPath(shimDir: string, originalPath: string): string;
+//# sourceMappingURL=shim-generator.d.ts.map

package/dist/packages/core/src/infrastructure/services/subprocess-filter/shim-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shim-generator.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/subprocess-filter/shim-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AASH,MAAM,WAAW,aAAa;IAC5B,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;IACb,sDAAsD;IACtD,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,cAAc,EAAE,MAAM,GAAG,aAAa,CAiBzE;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAE/E"}

package/dist/packages/core/src/infrastructure/services/subprocess-filter/shim-generator.js

@@ -0,0 +1,53 @@
+/**
+ * Shim generator — creates a per-worker temp directory containing
+ * wrapper scripts that shadow real commands (git, npm, pnpm, yarn)
+ * and pipe their output through shep-filter.
+ *
+ * The temp directory is prepended to PATH in the subprocess env so
+ * that when Claude Code's Bash tool runs `git status`, it hits our
+ * wrapper first. The wrapper:
+ *
+ * 1. Sets SHEP_FILTER_SHIM_DIR so shep-filter can skip our dir when
+ *    resolving the real binary
+ * 2. Calls `node <path-to-shep-filter.js> <command> "$@"`
+ * 3. Exits with shep-filter's exit code
+ *
+ * On macOS/Linux the wrappers are bash scripts with +x.
+ * On Windows they are .cmd files (not yet implemented — TODO).
+ */
+import { mkdtempSync, writeFileSync, chmodSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+/** Commands we generate shims for. */
+const SHIMMED_COMMANDS = ['git', 'npm', 'pnpm', 'yarn'];
+/**
+ * Create a temp directory with shim scripts for all supported commands.
+ *
+ * @param shepFilterPath - Absolute path to the compiled shep-filter.js
+ * @returns The shim directory info needed for PATH prepending
+ */
+export function createShimDirectory(shepFilterPath) {
+    const shimDir = mkdtempSync(join(tmpdir(), 'shep-filter-'));
+    for (const cmd of SHIMMED_COMMANDS) {
+        const shimPath = join(shimDir, cmd);
+        const script = [
+            '#!/usr/bin/env bash',
+            '# Auto-generated shep-filter shim — do not edit',
+            `export SHEP_FILTER_SHIM_DIR="${shimDir}"`,
+            `exec node "${shepFilterPath}" "${cmd}" "$@"`,
+        ].join('\n');
+        writeFileSync(shimPath, script, 'utf-8');
+        chmodSync(shimPath, 0o755);
+    }
+    return { path: shimDir, commands: SHIMMED_COMMANDS };
+}
+/**
+ * Build a modified PATH string with the shim directory prepended.
+ *
+ * @param shimDir - The shim directory path
+ * @param originalPath - The original PATH from the environment
+ * @returns The new PATH value with shimDir first
+ */
+export function buildFilteredPath(shimDir, originalPath) {
+    return `${shimDir}:${originalPath}`;
+}

package/dist/packages/core/src/infrastructure/services/token-optimization/alias-compression.service.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Alias Compression Service
+ *
+ * Session dictionary-based alias compression for prompts. Scans text for
+ * repeated long strings (3+ occurrences, 20+ characters), assigns short
+ * aliases ($A1, $A2, ...), prepends a dictionary header, and replaces
+ * all occurrences. A net-positive check ensures the dictionary overhead
+ * does not exceed the savings from aliasing.
+ */
+import type { IAliasCompressionService, AliasCompressionResult } from '../../../application/ports/output/services/alias-compression.interface.js';
+export declare class AliasCompressionService implements IAliasCompressionService {
+    /**
+     * Apply alias compression to a prompt string.
+     *
+     * Strategy:
+     * 1. Find all substrings appearing 3+ times that are 20+ chars
+     * 2. Sort by frequency (most frequent first) for optimal alias assignment
+     * 3. Compute net savings — skip if dictionary overhead exceeds body savings
+     * 4. Build dictionary header and replace occurrences
+     */
+    compress(text: string): AliasCompressionResult;
+    /**
+     * Find all substrings that qualify for aliasing.
+     *
+     * Uses word-boundary-aware token extraction to find repeated multi-word
+     * strings. Scans for non-whitespace tokens of sufficient length, then
+     * checks if longer contiguous phrases also repeat enough times.
+     */
+    private findCandidates;
+    /**
+     * Remove candidates that are substrings of longer candidates with
+     * equal or greater frequency (the longer alias provides more savings).
+     */
+    private removeSubsumedCandidates;
+    /**
+     * Build the dictionary header string.
+     * Format: "## Aliases\n$A1 = "original"\n$A2 = "original"\n\n"
+     */
+    private buildDictionaryHeader;
+}
+//# sourceMappingURL=alias-compression.service.d.ts.map

package/dist/packages/core/src/infrastructure/services/token-optimization/alias-compression.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alias-compression.service.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/token-optimization/alias-compression.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,wBAAwB,EACxB,sBAAsB,EACvB,MAAM,oEAAoE,CAAC;AAmB5E,qBAAa,uBAAwB,YAAW,wBAAwB;IACtE;;;;;;;;OAQG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,sBAAsB;IA6C9C;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAyBtB;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IAkBhC;;;OAGG;IACH,OAAO,CAAC,qBAAqB;CAI9B"}

package/dist/packages/core/src/infrastructure/services/token-optimization/alias-compression.service.js

@@ -0,0 +1,111 @@
+/**
+ * Alias Compression Service
+ *
+ * Session dictionary-based alias compression for prompts. Scans text for
+ * repeated long strings (3+ occurrences, 20+ characters), assigns short
+ * aliases ($A1, $A2, ...), prepends a dictionary header, and replaces
+ * all occurrences. A net-positive check ensures the dictionary overhead
+ * does not exceed the savings from aliasing.
+ */
+/** Minimum number of occurrences for a string to qualify for aliasing. */
+const MIN_OCCURRENCES = 3;
+/** Minimum character length for a string to qualify for aliasing. */
+const MIN_LENGTH = 20;
+/** Alias prefix format: $A1, $A2, ... */
+const ALIAS_PREFIX = '$A';
+export class AliasCompressionService {
+    /**
+     * Apply alias compression to a prompt string.
+     *
+     * Strategy:
+     * 1. Find all substrings appearing 3+ times that are 20+ chars
+     * 2. Sort by frequency (most frequent first) for optimal alias assignment
+     * 3. Compute net savings — skip if dictionary overhead exceeds body savings
+     * 4. Build dictionary header and replace occurrences
+     */
+    compress(text) {
+        if (text === '') {
+            return { compressed: '', dictionaryHeader: '', aliasCount: 0 };
+        }
+        // Step 1: Find candidate strings
+        const candidates = this.findCandidates(text);
+        if (candidates.length === 0) {
+            return { compressed: text, dictionaryHeader: '', aliasCount: 0 };
+        }
+        // Step 2: Sort by frequency descending (most repeated first)
+        candidates.sort((a, b) => b.count - a.count);
+        // Step 3: Assign aliases and compute net savings
+        const aliases = candidates.map((candidate, index) => ({
+            ...candidate,
+            alias: `${ALIAS_PREFIX}${index + 1}`,
+        }));
+        // Calculate savings
+        const dictionaryHeader = this.buildDictionaryHeader(aliases);
+        const bodySavings = aliases.reduce((total, { original, alias, count }) => total + count * (original.length - alias.length), 0);
+        const netSavings = bodySavings - dictionaryHeader.length;
+        if (netSavings <= 0) {
+            return { compressed: text, dictionaryHeader: '', aliasCount: 0 };
+        }
+        // Step 4: Replace occurrences in text
+        let body = text;
+        for (const { original, alias } of aliases) {
+            body = body.replaceAll(original, alias);
+        }
+        return {
+            compressed: dictionaryHeader + body,
+            dictionaryHeader,
+            aliasCount: aliases.length,
+        };
+    }
+    /**
+     * Find all substrings that qualify for aliasing.
+     *
+     * Uses word-boundary-aware token extraction to find repeated multi-word
+     * strings. Scans for non-whitespace tokens of sufficient length, then
+     * checks if longer contiguous phrases also repeat enough times.
+     */
+    findCandidates(text) {
+        // Extract all non-whitespace tokens of 20+ chars
+        const longTokens = new Map();
+        // Match sequences of non-whitespace characters that are 20+ chars
+        const tokenRegex = /\S{20,}/g;
+        let match;
+        while ((match = tokenRegex.exec(text)) !== null) {
+            const token = match[0];
+            longTokens.set(token, (longTokens.get(token) ?? 0) + 1);
+        }
+        // Filter to candidates meeting the occurrence threshold
+        const candidates = [];
+        for (const [token, count] of longTokens) {
+            if (count >= MIN_OCCURRENCES && token.length >= MIN_LENGTH) {
+                candidates.push({ original: token, count });
+            }
+        }
+        // Remove candidates that are substrings of other candidates with same or higher count
+        return this.removeSubsumedCandidates(candidates);
+    }
+    /**
+     * Remove candidates that are substrings of longer candidates with
+     * equal or greater frequency (the longer alias provides more savings).
+     */
+    removeSubsumedCandidates(candidates) {
+        // Sort by length descending so longer strings are checked first
+        const sorted = [...candidates].sort((a, b) => b.original.length - a.original.length);
+        const result = [];
+        for (const candidate of sorted) {
+            const isSubsumed = result.some((existing) => existing.original.includes(candidate.original) && existing.count >= candidate.count);
+            if (!isSubsumed) {
+                result.push(candidate);
+            }
+        }
+        return result;
+    }
+    /**
+     * Build the dictionary header string.
+     * Format: "## Aliases\n$A1 = "original"\n$A2 = "original"\n\n"
+     */
+    buildDictionaryHeader(aliases) {
+        const lines = aliases.map(({ alias, original }) => `${alias} = "${original}"`);
+        return `## Aliases\n${lines.join('\n')}\n\n`;
+    }
+}

package/dist/packages/core/src/infrastructure/services/token-optimization/command-output-filter.service.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Command Output Filter Service
+ *
+ * Regex-based filter that reduces test/build/git output tokens embedded in
+ * prompts while preserving all error-relevant lines. Applies configurable
+ * filter policies within fenced code blocks only.
+ *
+ * Safety guarantee: any line containing error-related keywords is preserved
+ * verbatim regardless of other filter rules.
+ */
+import type { ICommandOutputFilterService, CommandOutputFilterResult } from '../../../application/ports/output/services/command-output-filter.interface.js';
+export declare class CommandOutputFilterService implements ICommandOutputFilterService {
+    /**
+     * Filter command output embedded in a prompt string.
+     *
+     * Detects fenced code blocks and applies reduction policies within them.
+     * Text outside code blocks is never modified. Lines containing error-related
+     * keywords are always preserved.
+     */
+    filter(prompt: string): CommandOutputFilterResult;
+}
+//# sourceMappingURL=command-output-filter.service.d.ts.map

package/dist/packages/core/src/infrastructure/services/token-optimization/command-output-filter.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-output-filter.service.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/token-optimization/command-output-filter.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,2BAA2B,EAC3B,yBAAyB,EAC1B,MAAM,wEAAwE,CAAC;AA2MhF,qBAAa,0BAA2B,YAAW,2BAA2B;IAC5E;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,yBAAyB;CAkDlD"}