@haystackeditor/cli 0.15.27 → 0.15.29

package/dist/triage/traces.js

@@ -1,311 +0,0 @@
-/**
- * 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) {
-        // Support both old ({type: "text", text}) and new ({id, text}) content blocks
-        if (typeof block?.text !== 'string')
-            continue;
-        if (block.type && block.type !== 'text')
-            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) {
-        // Support both old format (entry.message.role === 'user') and new (entry.type === 'user')
-        const role = entry.message?.role ?? entry?.type;
-        if (role !== 'user')
-            continue;
-        // Support both old format ({message: {content}}) and new ({content} at top level)
-        const msg = entry.message?.content ?? entry.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/schemas/traces.v1.json

@@ -1,53 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://docs.haystackeditor.com/cli/schemas/traces.v1.json",
-  "title": "haystack traces list|get --json",
-  "type": "object",
-  "additionalProperties": false,
-  "required": ["schema_version", "operation", "ref", "head_sha"],
-  "allOf": [
-    {
-      "if": { "properties": { "operation": { "const": "list" } } },
-      "then": { "required": ["checkpoints"] }
-    },
-    {
-      "if": { "properties": { "operation": { "const": "get" } } },
-      "then": { "required": ["checkpoint_id", "checkpoint", "chunks", "total_chunks", "total_chars", "next_cursor"] }
-    }
-  ],
-  "$defs": {
-    "checkpoint": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["checkpoint_id", "commit_sha", "commit_message", "timestamp", "summary", "user_prompt", "files_touched", "branch"],
-      "properties": {
-        "checkpoint_id": { "type": "string" },
-        "commit_sha": { "type": "string" },
-        "commit_message": { "type": "string" },
-        "timestamp": { "type": ["string", "null"] },
-        "summary": { "type": "string" },
-        "user_prompt": { "type": ["string", "null"] },
-        "files_touched": { "type": "array", "items": { "type": "string" } },
-        "branch": { "type": ["string", "null"] }
-      }
-    }
-  },
-  "properties": {
-    "schema_version": { "type": "string", "const": "1.0.0" },
-    "operation": { "type": "string", "enum": ["list", "get"] },
-    "ref": { "type": "string" },
-    "head_sha": { "type": "string" },
-    "checkpoints": { "type": "array", "items": { "$ref": "#/$defs/checkpoint" } },
-    "checkpoint_id": { "type": "string" },
-    "checkpoint": {
-      "anyOf": [
-        { "$ref": "#/$defs/checkpoint" },
-        { "type": "null" }
-      ]
-    },
-    "chunks": { "type": "array", "items": { "type": "string" } },
-    "total_chunks": { "type": "integer" },
-    "total_chars": { "type": "integer" },
-    "next_cursor": { "type": ["string", "null"] }
-  }
-}