triage-trip 0.1.0 → 0.1.4

package/README.md

@@ -1,146 +1,117 @@
-# `ai-blackbox`
+Markdown
+# triage-trip 
 
-> Autonomous AI Regression Triage & Provenance CLI. Pinpoint breaking contract changes introduced by AI coding tools in seconds.
+> Autonomous CLI to pinpoint and patch regressions introduced by AI code assistants (Cursor, Copilot).
 
-<p align="center">
-  <img src="./assets/demo.gif" alt="AI-Blackbox Demo" width="700">
-</p>
----
+![triage-trip Demo](assets/demo.gif)
 
 ## The Problem
+When you use AI coding assistants to refactor or draft features, errors often slip through:
+- Subtle schema property renames (`userId` ➔ `user_id`).
+- Dropped function arguments or breaking contract shifts.
+- Regressions that aren't caught until 3 commits later.
 
-AI coding assistants (Cursor, GitHub Copilot, Windsurf) dramatically accelerate drafting and refactoring code. However, they frequently cause **silent contract drift**:
-
-* An AI renames an object key or subtle schema attribute (e.g., `userId` ➔ `user_id`).
-* Standard linters and compilers pass because the syntax is completely valid.
-* Downstream modules crash 2–3 commits later with cryptic runtime errors (`TypeError: Cannot read properties of undefined`).
-* Developers spend 20–30 minutes manually inspecting multi-file diffs, running `git bisect`, and searching for what changed.
-
----
-
-## What `ai-blackbox` Does
-
-`ai-blackbox` connects the dots across your development environment to trace the exact lineage of a regression:
-
-```text
-[ User Prompt in IDE ] ➔ [ AI Generated Diff ] ➔ [ Git Commit ] ➔ [ Runtime Error ]
-                                                                          │
-                                                                   ai-blackbox triage
-                                                                          │
-                                                                          ▼
-                                                       • Exact Root Cause & Commit
-                                                       • Attributed AI Prompt
-                                                       • Semantic Contract Shift
-                                                       • Clean Unified Diff Patch
+Developers lose 30+ minutes digging through hundreds of lines of AI diffs trying to figure out which prompt broke the build.
 
-```
-
-1. **Inspects Git History:** Automatically reads uncommitted working changes and recent commits using `simple-git`.
-2. **Extracts AI Session Provenance:** Scans local IDE storage (e.g., Cursor's local SQLite database `state.vscdb`) to retrieve recent prompts and user instructions.
-3. **Triages Semantic Drift:** Correlates the runtime stack trace with recent AST modifications and prompts via the OpenAI API to deliver an instant diagnostic report.
+## How It Works
+`triage-trip` connects runtime failures back to their origin:
+1. **Reads Local Git Stream:** Analyzes unstaged changes and recent commit diffs.
+2. **Inspects Cursor Provenance:** Reads local IDE session SQLite databases (`state.vscdb`) to identify the exact human prompt that generated the regression.
+3. **Isolates Semantic Shifts:** Determines contract and schema breaks.
+4. **Interactive In-Memory Patching:** Applies clean unified diffs directly to your working tree via `git apply` with a single confirmation.
 
 ---
 
-## Installation
-
-### Prerequisites
-
-* **Node.js** (v18 or higher, ESM native)
-* An active **OpenAI API Key**
-
-### Local Setup
-
-```bash
-# Clone the repository
-git clone https://github.com/your-username/ai-blackbox.git
-cd ai-blackbox
-
-# Install dependencies
-npm install
-
-# Link executable globally (optional for direct CLI access)
-npm link
-
-```
+## Quick Start
 
-Set your OpenAI API key in your terminal environment or add it to a `.env` file:
+Run instantly without global installation:
 
 ```bash
-export OPENAI_API_KEY="sk-..."
+npx triage-trip triage "TypeError: Cannot read properties of undefined (reading 'toUpperCase')"
+Or install globally:
+
+Bash
+npm install -g triage-trip
+Environment Setup
+Set your preferred LLM API key:
+
+Bash
+export ANTHROPIC_API_KEY="your-anthropic-key"
+# or
+export OPENAI_API_KEY="your-openai-key"
+Usage
+Diagnose an Error Trace
+Bash
+triage-trip triage "Cannot read properties of undefined (reading 'toUpperCase')"
+Auto-Apply Patches Instantly
+Skip the confirmation prompt to patch immediately:
+
+Bash
+triage-trip triage "ReferenceError: getUserProfile is not defined" --yes
+Inspect More Commits
+Bash
+triage-trip triage "SyntaxError: Unexpected token" --commits 10
+License
+MIT
 
-```
 
 ---
 
-## Quickstart & Usage
-
-Run the triage engine directly against any runtime error message or stack trace:
+### Step 3: Commit and Publish
 
 ```bash
-# Via npm script
-node bin/cli.js triage "TypeError: Cannot read properties of undefined (reading 'toUpperCase')"
-
-# Or globally (if linked)
-ai-blackbox triage "TypeError: Cannot read properties of undefined (reading 'toUpperCase')"
-
-```
+# Stage the updated doc and new GIF
+git add README.md assets/demo.gif package.json bin/cli.js
 
-### Options
+# Commit
+git commit -m "docs: rebrand to triage-trip with new demo gif"
 
-* `<query_or_error>` *(required)*: The error message or failing test description.
-* `-c, --commits <number>`: Number of recent commits to analyze (default: `5`).
+# Push to your remote
+git push origin main
 
----
-
-## Example Output
+# Publish live on npm
+npm publish --access public
 
-```markdown
-■ AI-Blackbox Triage Engine
 
-✔ Root cause isolated.
+## Inspiration & Ecosystem
 
-1. **Root Cause**: The error occurs in `app.js` at line 6, where `profile.userId` is accessed. 
-   The breaking change was introduced in commit `b83c577` ("refactor: update user schema"), 
-   which modified the `getUserProfile` function in `user.js`.
+Large engineering organizations (like Uber with their internal autonomous debugging agents) have long relied on automated bisect and triage systems to catch regressions before they reach staging. 
 
-2. **Attributed Prompt**: "Rename userId to user_id across the returned profile object."
+However, existing enterprise tooling wasn't built for the AI code assistant era. When an LLM refactors multi-file repositories in Cursor or Copilot, conventional stack traces don't tell you which human prompt caused the contract shift. 
 
-3. **The Shift**: The `getUserProfile` function now returns `user_id` instead of `userId`, 
-   causing `profile.userId` to evaluate to `undefined`.
+`triage-trip` bridges that gap for every developer: a zero-overhead local CLI that brings automated root-cause isolation, Cursor prompt provenance, and in-memory patching right to your terminal.
 
-4. **Patch**:
---- a/app.js
-+++ b/app.js
-@@ -6,2 +6,2 @@
--  console.log(`Loading dashboard for user ID: ${profile.userId.toUpperCase()}`);
-+  console.log(`Loading dashboard for user ID: ${profile.user_id.toUpperCase()}`);
+## Security & Privacy
+- **Read-Only SQLite Access:** `triage-trip` reads local IDE databases (`state.vscdb`) in strict read-only mode (`readonly: true`). It never modifies editor settings or session files.
+- **Direct LLM Communication:** Your repository context and diffs are sent directly to Anthropic or OpenAI using your own local environment API keys. No intermediate servers, telemetry trackers, or external logging daemons.
 
-```
+## Compatibility
+- **IDEs:** Cursor (Full prompt provenance support via local Composer storage), VS Code / Windsurf (Git diff & contract triage)
+- **Platforms:** macOS, Linux, Windows (WSL / PowerShell)
+- **Runtime:** Node.js `>= 18.0.0`
 
----
+## CLI Options
 
-## Project Structure
+| Flag | Default | Description |
+| :--- | :--- | :--- |
+| `-c, --commits <num>` | `5` | Number of recent commits to inspect alongside unstaged working diffs |
+| `-y, --yes` | `false` | Automatically apply the proposed patch without an interactive prompt |
+| `-V, --version` | | Display current version |
+| `-h, --help` | | Display help and usage options |
 
-```text
-ai-blackbox/
-├── bin/
-│   └── cli.js            # CLI commands & terminal output formatting (Commander, Ora, Picocolors)
-├── src/
-│   ├── git.js            # Working tree and commit diff extraction (simple-git)
-│   ├── cursor.js         # Cursor SQLite database parser (better-sqlite3)
-│   └── triage.js         # OpenAI triage diagnostic engine (GPT-4o)
-├── package.json
-└── README.md
+## Development
 
-```
+```bash
+git clone [https://github.com/arules3/triage-trip.git](https://github.com/arules3/triage-trip.git)
+cd triage-trip
+npm install
+npm link
 
----
 
-## Roadmap
+## Current Status & Roadmap
 
-* [x] Git diff & commit stream extraction
-* [x] Local SQLite prompt extraction for Cursor Composer
-* [x] OpenAI regression diagnostic engine
-* [ ] Auto-patch application flag (`--fix` via `git apply`)
-* [ ] Multi-IDE adapters (GitHub Copilot Chat, Windsurf Cascade, Claude Code)
-* [ ] GitHub Action runner for automated PR failure triage
+### What's Working Today (`v0.1.0`)
+- **Git Context Analysis:** Reads unstaged working tree diffs and recent commit logs.
+- **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).

package/bin/cli.js

@@ -24,25 +24,32 @@ program
   .option('-c, --commits <number>', 'Number of recent commits to analyze', '5')
   .option('-y, --yes', 'Automatically apply the patch without asking', false)
   .action(async (errorInput, options) => {
-    console.log(pc.bold(pc.cyan('\n■ AI-Blackbox Triage Engine\n')));
+    console.log(pc.bold(pc.cyan('\n■ Triage-Trip Engine\n')));
 
     const spinner = ora('Reading recent git changes & Cursor prompts...').start();
     let diagnosis = '';
-    
+
     try {
       const commitCount = parseInt(options.commits, 10);
       const [changes, prompts] = await Promise.all([
-        getRecentChanges(commitCount),
+        getRecentChanges(commitCount, errorInput),
         Promise.resolve().then(() => getRecentCursorPrompts(10))
       ]);
 
       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);
     }
 
@@ -60,16 +67,21 @@ program
       }
 
       if (shouldApply) {
-        const patchSpinner = ora('Applying patch via git apply...').start();
+        const patchSpinner = ora('Applying patch to working tree...').start();
         try {
-          await applyDiff(patch);
+          const res = await applyDiff(patch);
           patchSpinner.succeed(pc.green('Patch applied successfully to working tree.'));
+          if (res?.modifiedFiles && res.modifiedFiles.length > 0) {
+            console.log(pc.dim(`Modified: ${res.modifiedFiles.join(', ')}`));
+          }
           console.log(pc.dim('Run `git diff` to review or `git commit` to save the fix.\n'));
         } catch (err) {
-          patchSpinner.fail(pc.red(err.message));
+          patchSpinner.fail(pc.red('Patch application failed: ' + err.message));
         }
       }
+    } else {
+      console.log(pc.dim('ℹ No executable patch block was detected in the diagnostic report.\n'));
     }
   });
 
-program.parse(process.argv);
+program.parse(process.argv);

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "triage-trip",
-  "version": "0.1.0",
+  "version": "0.1.4",
   "description": "Autonomous CLI to pinpoint and patch regressions introduced by AI code assistants",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "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/git.js

@@ -1,4 +1,6 @@
 import { simpleGit } from 'simple-git';
+import fs from 'fs';
+import path from 'path';
 
 const git = simpleGit();
 
@@ -13,7 +15,126 @@ function sanitizeDiff(diffStr, maxChars = 4000) {
   return diffStr;
 }
 
-export async function getRecentChanges(maxCommits = 3) {
+const BINARY_EXTENSIONS = new Set([
+  '.gif', '.png', '.jpg', '.jpeg', '.cast', '.ico', '.pdf', '.zip',
+  '.tar', '.gz', '.db', '.sqlite', '.sqlite3', '.bin', '.wasm'
+]);
+
+/**
+ * Collects active working copy text for relevant files with line numbers.
+ * Gives the LLM exact source of truth for current file state, eliminating hallucinated diffs.
+ */
+function collectActiveFiles(status, commitDiffs, errorInput = '', maxFiles = 5) {
+  const candidates = new Set();
+
+  // 1. Extract file paths from error input / stack trace
+  if (errorInput) {
+    const fileMatches = errorInput.match(/(?:[a-zA-Z0-9_\-\.\/]+\/)?([a-zA-Z0-9_\-\.]+\.[a-zA-Z0-9]+)/g) || [];
+    for (const match of fileMatches) {
+      const cleanPath = match.replace(/^(?:file:\/\/\/|\/)/, '');
+      candidates.add(cleanPath);
+      candidates.add(path.basename(cleanPath));
+    }
+  }
+
+  // 2. Working tree files from git status
+  const statusFiles = [
+    ...(status.modified || []),
+    ...(status.staged || []),
+    ...(status.created || []),
+    ...(status.not_added || []),
+  ];
+  for (const f of statusFiles) candidates.add(f);
+
+  // 3. Files from latest commit diff
+  if (commitDiffs.length > 0 && commitDiffs[0].diff) {
+    const diffFiles = commitDiffs[0].diff.match(/(?:---|\+\+\+)\s+[ab]\/([^\s\n]+)/g) || [];
+    for (const df of diffFiles) {
+      const p = df.replace(/^(?:---|\+\+\+)\s+[ab]\//, '');
+      candidates.add(p);
+    }
+  }
+
+  const activeFiles = {};
+  let count = 0;
+
+  for (const candidate of candidates) {
+    if (count >= maxFiles) break;
+
+    // Resolve file
+    let fullPath = path.resolve(process.cwd(), candidate);
+    if (!fs.existsSync(fullPath)) {
+      // Try resolving by basename in workspace
+      const baseName = path.basename(candidate);
+      const found = findCandidateFile(process.cwd(), baseName);
+      if (found) fullPath = found;
+      else continue;
+    }
+
+    const ext = path.extname(fullPath).toLowerCase();
+    if (BINARY_EXTENSIONS.has(ext)) continue;
+    if (fullPath.includes('node_modules') || fullPath.includes('.git')) continue;
+
+    try {
+      const stat = fs.statSync(fullPath);
+      if (!stat.isFile() || stat.size > 50000) continue;
+
+      const content = fs.readFileSync(fullPath, 'utf8');
+      const relPath = path.relative(process.cwd(), fullPath);
+
+      const lines = content.split('\n');
+      const formatted = lines
+        .slice(0, 150)
+        .map((line, idx) => `${idx + 1}| ${line}`)
+        .join('\n');
+
+      activeFiles[relPath] = formatted;
+      count++;
+
+      // Also inspect relative local imports for JS/TS
+      if (['.js', '.ts', '.jsx', '.tsx', '.mjs'].includes(ext)) {
+        const importMatches = content.match(/(?:import|require)\s*\(?['"](\.[^'"]+)['"]/g) || [];
+        for (const imp of importMatches) {
+          const importRel = imp.match(/['"](\.[^'"]+)['"]/)?.[1];
+          if (importRel) {
+            const dir = path.dirname(fullPath);
+            let importedPath = path.resolve(dir, importRel);
+            if (!fs.existsSync(importedPath) && fs.existsSync(importedPath + '.js')) {
+              importedPath = importedPath + '.js';
+            }
+            if (fs.existsSync(importedPath) && !activeFiles[path.relative(process.cwd(), importedPath)]) {
+              candidates.add(path.relative(process.cwd(), importedPath));
+            }
+          }
+        }
+      }
+    } catch {}
+  }
+
+  return activeFiles;
+}
+
+function findCandidateFile(dir, baseName, depth = 0) {
+  if (depth > 4) return null;
+  const ignored = new Set(['node_modules', '.git', 'dist', 'build', '.cache', 'coverage']);
+
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const ent of entries) {
+      if (ent.isDirectory()) {
+        if (!ignored.has(ent.name)) {
+          const found = findCandidateFile(path.join(dir, ent.name), baseName, depth + 1);
+          if (found) return found;
+        }
+      } else if (ent.isFile() && ent.name === baseName) {
+        return path.join(dir, ent.name);
+      }
+    }
+  } catch {}
+  return null;
+}
+
+export async function getRecentChanges(maxCommits = 3, errorInput = '') {
   const isRepo = await git.checkIsRepo();
   if (!isRepo) {
     throw new Error('Not inside a valid Git repository.');
@@ -27,6 +148,9 @@ export async function getRecentChanges(maxCommits = 3) {
     ':!yarn.lock',
     ':!pnpm-lock.yaml',
     ':!bun.lockb',
+    ':!assets/*',
+    ':!*.gif',
+    ':!*.cast',
   ];
 
   const unstagedDiff = await git.diff(['--', '.', ...lockfileIgnores]);
@@ -58,10 +182,13 @@ export async function getRecentChanges(maxCommits = 3) {
     })
   );
 
+  const activeFileContents = collectActiveFiles(status, commitDiffs, errorInput);
+
   return {
     branch: status.current,
-    untrackedFiles: status.not_added, // Tells the LLM if newly created files exist
+    untrackedFiles: status.not_added,
     workingDiff: sanitizeDiff(combinedWorkingDiff) || null,
     recentCommits: commitDiffs,
+    activeFileContents,
   };
-}
+}