triage-trip 0.1.3 → 0.1.4

package/README.md

@@ -115,9 +115,3 @@ npm link
 - **Cursor Prompt Provenance:** Direct read-only extraction from local `state.vscdb` to link regressions to specific Composer prompts.
 - **Root Cause Isolation:** LLM-assisted semantic contract shift detection.
 - **Interactive Patching:** Clean, in-memory `git apply` with user confirmation prompts (`--yes` fallback).
-
-### On the Horizon
-- [ ] **Automated Test Verification:** Automatically run project test suites (`npm test`, `pytest`) to verify fixes before finalizing patches.
-- [ ] **Expanded IDE Provenance:** Support for Windsurf (`cascade`), VS Code Copilot Chat, and Claude Code logs.
-- [ ] **GitHub Action / CI Mode:** Comment directly on failed PR runs with the attributed prompt and proposed fix.
-- [ ] **Deterministic AST Diffing:** Local offline schema diffing before LLM invocation to cut latency and token usage.

package/bin/cli.js

@@ -37,12 +37,19 @@ program
       ]);
 
       spinner.text = 'Isolating structural contract shifts and AST regressions...';
-      diagnosis = await triageRegression(errorInput, changes, prompts);
+      diagnosis = await triageRegression(errorInput, changes, prompts, () => {
+        // Stop spinner before the first streamed token so ora doesn't garble stdout
+        spinner.stop();
+        process.stdout.write('\n');
+      });
 
-      spinner.succeed(pc.green('Root cause isolated.'));
-      console.log('\n' + diagnosis + '\n');
+      console.log('\n' + pc.green('✓ Root cause isolated.') + '\n');
     } catch (err) {
-      spinner.fail(pc.red('Triage failed: ' + err.message));
+      if (spinner.isSpinning) {
+        spinner.fail(pc.red('Triage failed: ' + err.message));
+      } else {
+        console.error(pc.red('\nTriage failed: ' + err.message));
+      }
       process.exit(1);
     }
 

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "triage-trip",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Autonomous CLI to pinpoint and patch regressions introduced by AI code assistants",
   "main": "index.js",
   "scripts": {
-    "test": "node test/patch.test.js"
+    "test": "node test/patch.test.js && node test/simulation.test.js && node test/streaming.test.js",
+    "test:sim": "node test/simulation.test.js",
+    "test:stream": "node test/streaming.test.js"
   },
   "keywords": [
     "cursor",

package/src/triage.js

@@ -1,8 +1,22 @@
 // src/triage.js
 import OpenAI from 'openai';
 import Anthropic from '@anthropic-ai/sdk';
+import { cleanGitContext } from './utils.js';
+
+export async function triageRegression(
+  errorDescription,
+  gitContext,
+  editorPrompts = [],
+  onStreamStart,
+  deps = {},
+) {
+  if (!errorDescription || typeof errorDescription !== 'string' || !errorDescription.trim()) {
+    throw new Error('Query or error trace cannot be empty.');
+  }
+
+  const AnthropicClient = deps.Anthropic || Anthropic;
+  const OpenAIClient = deps.OpenAI || OpenAI;
 
-export async function triageRegression(errorDescription, gitContext, cursorPrompts = []) {
   const anthropicKey = process.env.ANTHROPIC_API_KEY;
   const openaiKey = process.env.OPENAI_API_KEY;
 
@@ -23,38 +37,49 @@ When generating the "Patch" section:
 - Ensure @@ -line,count +line,count @@ markers accurately match the context.
 - Include 1-2 lines of unchanged surrounding context above and below the change.
 - Only touch lines that actually exist in the file.
-- Match the exact current text and casing from the active working file on disk as the '-' (removed) lines.
+- The '-' (removed) lines MUST match the EXACT text, indentation, and casing from the active working file on disk.
 `.trim();
 
-  const activeFilesSection = gitContext.activeFileContents && Object.keys(gitContext.activeFileContents).length > 0
-    ? `Active Working Files on Disk (Current File Contents & Line Numbers):\n${JSON.stringify(gitContext.activeFileContents, null, 2)}`
+  const safeGitContext = cleanGitContext(gitContext);
+
+  const activeFilesSection = safeGitContext.activeFileContents && Object.keys(safeGitContext.activeFileContents).length > 0
+    ? `Active Working Files on Disk (Current File Contents & Line Numbers):\n${JSON.stringify(safeGitContext.activeFileContents, null, 2)}`
     : '';
 
+  const hasPrompts = Array.isArray(editorPrompts) && editorPrompts.length > 0;
+  const promptsSection = hasPrompts
+    ? `Recent IDE / Editor Prompts:\n${JSON.stringify(editorPrompts, null, 2)}`
+    : 'No local IDE prompt telemetry available. Attribute cause using Git commit messages and diffs.';
+
+  const attributedStepLabel = hasPrompts ? 'Attributed Prompt' : 'Attributed Intent';
+  const attributedStepDetail = hasPrompts
+    ? 'Name the specific IDE/editor prompt that likely caused this diff (if found in the list; otherwise state none).'
+    : 'Infer the likely author intent from Git commit messages and diffs (no IDE prompt telemetry available).';
+
   const userPrompt = `
 User problem / error trace:
 "${errorDescription}"
 
 ${activeFilesSection}
 
-Recent Cursor Composer Prompts:
-${JSON.stringify(cursorPrompts, null, 2)}
+${promptsSection}
 
 Recent Repository Git Stream (Working diff + Commits):
 ${JSON.stringify({
-  branch: gitContext.branch,
-  untrackedFiles: gitContext.untrackedFiles,
-  workingDiff: gitContext.workingDiff,
-  recentCommits: gitContext.recentCommits,
+  branch: safeGitContext.branch,
+  untrackedFiles: safeGitContext.untrackedFiles,
+  workingDiff: safeGitContext.workingDiff,
+  recentCommits: safeGitContext.recentCommits,
 }, null, 2)}
 
 Provide a strict, concise triage output formatted with terminal-friendly Markdown:
 1. **Root Cause**: Pinpoint the file, line, and commit/working diff where the breaking change occurred.
-2. **Attributed Prompt**: Name the specific Cursor prompt that likely caused this diff (if found in the list; otherwise state none).
+2. **${attributedStepLabel}**: ${attributedStepDetail}
 3. **The Shift**: Explain what broke (e.g., schema key rename, dropped parameter, async/await omission).
 4. **Patch**: Provide the exact unified diff adhering strictly to the system diff formatting instructions.
 
 CRITICAL RULES FOR THE PATCH:
-- The '-' (removed) lines MUST match the EXACT text and casing currently in the file shown in "Active Working Files on Disk".
+- The '-' (removed) lines MUST match the EXACT text, indentation, and casing currently in the file shown in "Active Working Files on Disk".
 - Target the file accurately:
   --- a/<path>
   +++ b/<path>
@@ -63,35 +88,65 @@ CRITICAL RULES FOR THE PATCH:
 - Only change the breaking line(s). Keep 1-2 lines of unchanged surrounding context lines above and below without '+' or '-'.
 - Example format:
 \`\`\`diff
---- a/app.js
-+++ b/app.js
-@@ -6,3 +6,3 @@
+--- a/src/app.js
++++ b/src/app.js
+@@ -5,3 +5,3 @@
+   const profile = getUserProfile();
 -  console.log(\`Loading dashboard for user ID: \${profile.userid.toUpperCase()}\`);
 +  console.log(\`Loading dashboard for user ID: \${profile.user_id.toUpperCase()}\`);
+   return profile;
 \`\`\`
 `;
 
+  let streamStarted = false;
+  const emitChunk = (text) => {
+    if (!text) return;
+    if (!streamStarted) {
+      streamStarted = true;
+      if (typeof onStreamStart === 'function') onStreamStart();
+    }
+    process.stdout.write(text);
+  };
+
   // 1. Prefer Anthropic if key exists
   if (anthropicKey) {
-    const anthropic = new Anthropic({ apiKey: anthropicKey });
-    const response = await anthropic.messages.create({
-      model: 'claude-3-5-sonnet-20241022',
+    const anthropic = new AnthropicClient({ apiKey: anthropicKey });
+    const stream = await anthropic.messages.create({
+      model: process.env.ANTHROPIC_MODEL || 'claude-3-5-sonnet-latest',
       max_tokens: 1500,
       system: systemInstructions,
-      messages: [{ role: 'user', content: userPrompt }]
+      messages: [{ role: 'user', content: userPrompt }],
+      stream: true,
     });
-    return response.content[0].text;
+
+    let fullText = '';
+    for await (const event of stream) {
+      if (event.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
+        const chunk = event.delta.text || '';
+        emitChunk(chunk);
+        fullText += chunk;
+      }
+    }
+    return fullText;
   }
 
   // 2. Fallback to OpenAI
-  const openai = new OpenAI({ apiKey: openaiKey });
-  const response = await openai.chat.completions.create({
-    model: 'gpt-4o-mini',
+  const openai = new OpenAIClient({ apiKey: openaiKey });
+  const stream = await openai.chat.completions.create({
+    model: process.env.OPENAI_MODEL || 'gpt-4o',
     temperature: 0.1,
+    stream: true,
     messages: [
       { role: 'system', content: systemInstructions },
       { role: 'user', content: userPrompt }
     ]
   });
-  return response.choices[0].message.content;
+
+  let fullText = '';
+  for await (const chunk of stream) {
+    const text = chunk.choices[0]?.delta?.content || '';
+    emitChunk(text);
+    fullText += text;
+  }
+  return fullText;
 }

package/src/utils.js

@@ -0,0 +1,63 @@
+const LOCKFILE_NAMES = new Set([
+  'package-lock.json',
+  'yarn.lock',
+  'pnpm-lock.yaml',
+  'bun.lockb',
+]);
+
+const MAX_DIFF_CHARS = 3000;
+const MAX_FILE_CHARS = 3000;
+
+function isLockfile(filePath) {
+  if (!filePath || typeof filePath !== 'string') return false;
+  const base = filePath.split(/[/\\]/).pop();
+  return LOCKFILE_NAMES.has(base);
+}
+
+function truncateDiff(diffStr) {
+  if (!diffStr || typeof diffStr !== 'string') return diffStr ?? null;
+  if (diffStr.length <= MAX_DIFF_CHARS) return diffStr;
+  return diffStr.slice(0, MAX_DIFF_CHARS) + '...[Diff truncated for length]';
+}
+
+function truncateFileContent(content) {
+  if (!content || typeof content !== 'string') return content;
+  if (content.length <= MAX_FILE_CHARS) return content;
+  return content.slice(0, MAX_FILE_CHARS) + '...[File truncated for length]';
+}
+
+/**
+ * Filters lockfiles and truncates large diffs/file contents to keep LLM prompts within context limits.
+ */
+export function cleanGitContext(gitContext = {}) {
+  const untrackedFiles = Array.isArray(gitContext.untrackedFiles)
+    ? gitContext.untrackedFiles.filter((f) => !isLockfile(f))
+    : gitContext.untrackedFiles;
+
+  const workingDiff = truncateDiff(gitContext.workingDiff);
+
+  const recentCommits = Array.isArray(gitContext.recentCommits)
+    ? gitContext.recentCommits.map((commit) => ({
+        ...commit,
+        diff: truncateDiff(commit?.diff),
+      }))
+    : gitContext.recentCommits;
+
+  let activeFileContents = gitContext.activeFileContents;
+  if (activeFileContents && typeof activeFileContents === 'object') {
+    activeFileContents = Object.fromEntries(
+      Object.entries(activeFileContents).map(([path, content]) => [
+        path,
+        truncateFileContent(content),
+      ])
+    );
+  }
+
+  return {
+    ...gitContext,
+    untrackedFiles,
+    workingDiff,
+    recentCommits,
+    activeFileContents,
+  };
+}