@haystackeditor/cli 0.8.0 → 0.9.0

package/dist/triage/traces.js

@@ -0,0 +1,305 @@
+/**
+ * Local Entire CLI trace discovery for intent drift analysis.
+ *
+ * Finds .entire/metadata/ session files whose modified files
+ * overlap with the current diff's changed files.
+ */
+import { execSync } from 'child_process';
+import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+/**
+ * Get the list of files changed in the current diff vs base branch.
+ */
+function getChangedFiles(gitRoot, baseBranch) {
+    try {
+        const output = execSync(`git diff ${baseBranch}...HEAD --name-only`, {
+            encoding: 'utf-8',
+            cwd: gitRoot,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        if (!output)
+            return [];
+        return output.split('\n').filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Extract file paths mentioned in a JSONL trace file.
+ *
+ * Looks for file paths in tool_use content blocks (Write, Edit, Read operations)
+ * by scanning for common path patterns in the JSONL entries.
+ */
+function extractFilesFromTrace(tracePath) {
+    const files = new Set();
+    try {
+        const content = readFileSync(tracePath, 'utf-8');
+        const lines = content.split('\n').filter(Boolean);
+        for (const line of lines) {
+            try {
+                const entry = JSON.parse(line);
+                // Look for file paths in tool use inputs
+                // Claude Code format: { type: "tool_use", name: "Write"|"Edit"|"Read", input: { file_path: "..." } }
+                if (entry?.type === 'tool_use' || entry?.message?.content) {
+                    const text = typeof entry === 'string' ? entry : JSON.stringify(entry);
+                    // Match file_path values
+                    const filePathMatches = text.match(/"file_path"\s*:\s*"([^"]+)"/g);
+                    if (filePathMatches) {
+                        for (const match of filePathMatches) {
+                            const pathMatch = match.match(/"file_path"\s*:\s*"([^"]+)"/);
+                            if (pathMatch?.[1]) {
+                                // Normalize: strip leading ./ and absolute path prefixes
+                                let filePath = pathMatch[1];
+                                filePath = filePath.replace(/^\.\//, '');
+                                // Extract relative path if absolute
+                                const parts = filePath.split('/');
+                                // Keep as-is for now; the overlap check handles it
+                                files.add(filePath);
+                            }
+                        }
+                    }
+                }
+            }
+            catch {
+                // Skip malformed JSONL lines
+            }
+        }
+    }
+    catch {
+        // File read error
+    }
+    return Array.from(files);
+}
+/**
+ * Check if any file from the trace overlaps with changed files.
+ * Uses fuzzy matching: a trace file "src/foo.ts" matches changed file "src/foo.ts",
+ * and an absolute path "/repo/src/foo.ts" matches "src/foo.ts" by suffix.
+ */
+function hasOverlap(traceFiles, changedFiles) {
+    for (const tf of traceFiles) {
+        for (const cf of changedFiles) {
+            if (tf === cf || tf.endsWith('/' + cf) || cf.endsWith('/' + tf)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Matches a complete slash-command block from <command-name> through the last
+ * </command-*> tag. The block structure is:
+ *   <command-name>/foo</command-name>
+ *   <command-message>...</command-message>
+ *   <command-args>...</command-args>
+ *
+ * We match each tag group individually and make message/args optional so partial
+ * blocks (e.g., name-only) are still stripped.
+ */
+const COMMAND_BLOCK_RE = /<command-name>\s*\/[^<]*<\/command-name>(?:\s*<command-message>[\s\S]*?<\/command-message>)?(?:\s*<command-args>[\s\S]*?<\/command-args>)?\s*/g;
+/**
+ * Matches a single <local-command-caveat>...</local-command-caveat> wrapper.
+ * Non-greedy so adjacent caveats are matched individually (avoids eating
+ * human text between two caveats).
+ */
+const CAVEAT_RE = /<local-command-caveat>[\s\S]*?<\/local-command-caveat>\s*/g;
+/**
+ * Anchored: matches only when the entire string (after trimming) is one or
+ * more command blocks with no surrounding human text.
+ */
+const COMMAND_ONLY_RE = /^\s*(?:<command-name>\s*\/[^<]*<\/command-name>(?:\s*<command-message>[\s\S]*?<\/command-message>)?(?:\s*<command-args>[\s\S]*?<\/command-args>)?\s*)+$/;
+/**
+ * Strip machine-generated wrappers from a text block so only the
+ * human-authored content remains. Removes:
+ * - <local-command-caveat>...</local-command-caveat> wrappers (individually)
+ * - <command-name>...(closing tag) slash-command blocks
+ */
+function stripWrappers(text) {
+    return text
+        .replace(CAVEAT_RE, '')
+        .replace(COMMAND_BLOCK_RE, '')
+        .trim();
+}
+/**
+ * Returns true if the text consists entirely of slash-command blocks with no
+ * surrounding human text. Anchored to avoid false positives when a user
+ * message merely quotes or references a command tag.
+ */
+function isSlashCommand(text) {
+    return COMMAND_ONLY_RE.test(text);
+}
+/**
+ * Extract the human-authored text from a message content value.
+ *
+ * Content can be a plain string or a block array. For block arrays, we pull
+ * only `{ type: "text" }` blocks (skipping tool_result, tool_reference, etc.)
+ * and strip machine wrappers from each block individually.
+ */
+function extractHumanText(content) {
+    if (typeof content === 'string') {
+        const stripped = stripWrappers(content);
+        if (!stripped || isSlashCommand(stripped))
+            return null;
+        return stripped;
+    }
+    if (!Array.isArray(content))
+        return null;
+    const textParts = [];
+    for (const block of content) {
+        if (block?.type !== 'text' || typeof block.text !== 'string')
+            continue;
+        const stripped = stripWrappers(block.text);
+        if (stripped && !isSlashCommand(stripped)) {
+            textParts.push(stripped);
+        }
+    }
+    return textParts.length > 0 ? textParts.join('\n') : null;
+}
+/**
+ * Extract only user-role messages from a JSONL trace file.
+ *
+ * The raw trace contains tool results, assistant reasoning, and tool_use blocks
+ * that can bloat a single session to 10MB+. The intent-drift checker only needs
+ * the user's actual messages to judge whether the agent fulfilled the request.
+ *
+ * Filters out:
+ * - tool_result / tool_reference blocks (machine output, not user intent)
+ * - All slash-command messages (not just /clear)
+ * - local-command-caveat wrappers (stripped per-block for arrays)
+ */
+/**
+ * Parse JSONL content that may contain multi-line JSON entries.
+ *
+ * Tries each line as a standalone JSON object first (fast path). On parse
+ * failure, accumulates subsequent lines until a valid object is formed or
+ * a cap is hit, so multi-line entries aren't silently dropped.
+ */
+function parseJsonl(content, tracePath) {
+    const entries = [];
+    const lines = content.split('\n');
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i].trim();
+        if (!line) {
+            i++;
+            continue;
+        }
+        try {
+            entries.push(JSON.parse(line));
+            i++;
+        }
+        catch {
+            // Accumulate lines for a multi-line entry (cap at 50 lines)
+            let accumulated = line;
+            let found = false;
+            const limit = Math.min(i + 50, lines.length);
+            let j = i + 1;
+            while (j < limit) {
+                accumulated += '\n' + lines[j];
+                try {
+                    entries.push(JSON.parse(accumulated));
+                    found = true;
+                    j++;
+                    break;
+                }
+                catch {
+                    j++;
+                }
+            }
+            if (!found) {
+                console.error(`[traces] Unparseable JSONL at line ${i + 1} in ${tracePath}`);
+                // Only skip the single unparseable line — don't jump to j which
+                // would skip valid entries that were probed during accumulation.
+                i++;
+            }
+            else {
+                i = j;
+            }
+        }
+    }
+    return entries;
+}
+function extractUserMessages(tracePath) {
+    const messages = [];
+    let content;
+    try {
+        content = readFileSync(tracePath, 'utf-8');
+    }
+    catch (err) {
+        console.error(`[traces] Failed to read trace file ${tracePath}: ${err}`);
+        return messages;
+    }
+    const entries = parseJsonl(content, tracePath);
+    for (const entry of entries) {
+        if (entry?.type !== 'user')
+            continue;
+        const msg = entry.message?.content;
+        if (!msg)
+            continue;
+        const text = extractHumanText(msg);
+        if (text) {
+            messages.push(text);
+        }
+    }
+    return messages;
+}
+/**
+ * Find local Entire CLI trace files relevant to the current diff.
+ *
+ * Scans .entire/metadata/ for session directories containing full.jsonl,
+ * then checks if any files modified in those sessions overlap with the
+ * files changed in the current diff.
+ *
+ * Returns paths to condensed files containing only user messages (not the
+ * raw multi-MB traces). This keeps the intent-drift sub-agent focused on
+ * user intent without burning its context window on tool outputs.
+ *
+ * @returns Array of absolute paths to condensed user-messages files
+ */
+export function findRelevantTraces(gitRoot, baseBranch) {
+    const metadataDir = join(gitRoot, '.entire', 'metadata');
+    if (!existsSync(metadataDir)) {
+        return [];
+    }
+    const changedFiles = getChangedFiles(gitRoot, baseBranch);
+    if (changedFiles.length === 0) {
+        return [];
+    }
+    const triageDir = join(gitRoot, '.haystack', 'triage', 'traces');
+    mkdirSync(triageDir, { recursive: true });
+    const relevantTraces = [];
+    let sessions;
+    try {
+        sessions = readdirSync(metadataDir, { withFileTypes: true });
+    }
+    catch (err) {
+        console.error(`[traces] Failed to read metadata directory ${metadataDir}: ${err}`);
+        return relevantTraces;
+    }
+    let traceIndex = 0;
+    for (const session of sessions) {
+        if (!session.isDirectory())
+            continue;
+        const tracePath = join(metadataDir, session.name, 'full.jsonl');
+        if (!existsSync(tracePath))
+            continue;
+        const traceFiles = extractFilesFromTrace(tracePath);
+        if (hasOverlap(traceFiles, changedFiles)) {
+            const userMessages = extractUserMessages(tracePath);
+            if (userMessages.length === 0)
+                continue;
+            // Use a monotonic index prefix to avoid collisions if session names
+            // are reused across metadata directories.
+            const condensedPath = join(triageDir, `${traceIndex}-${session.name}.txt`);
+            traceIndex++;
+            try {
+                writeFileSync(condensedPath, userMessages.map((m, i) => `--- User message ${i + 1} ---\n${m}`).join('\n\n'));
+                relevantTraces.push(condensedPath);
+            }
+            catch (err) {
+                console.error(`[traces] Failed to write condensed trace ${condensedPath}: ${err}`);
+            }
+        }
+    }
+    return relevantTraces;
+}

package/dist/triage/types.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Types for the pre-PR triage system.
+ *
+ * Sub-agents write results as JSON files matching these schemas.
+ * The runner reads and aggregates them.
+ */
+export type TriageSeverity = 'error' | 'warning' | 'info';
+export interface TriageIssue {
+    file: string;
+    line?: number;
+    severity: TriageSeverity;
+    message: string;
+    /** For rules validator: rule ID (e.g., PR001) */
+    rule?: string;
+    /** For intent drift: drift pattern */
+    pattern?: 'intent_drift' | 'incomplete_fulfillment';
+}
+export interface CodeReviewResult {
+    checker: 'code-review';
+    issues: TriageIssue[];
+    summary: string;
+    passed: boolean;
+}
+export interface RulesValidatorResult {
+    checker: 'rules-validator';
+    issues: TriageIssue[];
+    summary: string;
+    passed: boolean;
+    rulesChecked: number;
+}
+export interface IntentDriftResult {
+    checker: 'intent-drift';
+    issues: TriageIssue[];
+    summary: string;
+    passed: boolean;
+    sessionsChecked: number;
+}
+export type CheckerResult = CodeReviewResult | RulesValidatorResult | IntentDriftResult;
+export interface TriageResult {
+    passed: boolean;
+    results: CheckerResult[];
+    /** Errors from sub-agent crashes or missing output */
+    errors: string[];
+    /** Total duration in ms */
+    duration: number;
+}
+export type AgenticCLI = 'claude' | 'codex' | 'gemini';

package/dist/triage/types.js

@@ -0,0 +1,7 @@
+/**
+ * Types for the pre-PR triage system.
+ *
+ * Sub-agents write results as JSON files matching these schemas.
+ * The runner reads and aggregates them.
+ */
+export {};