jstar-reviewer 2.1.3 → 2.2.0

package/dist/scripts/reviewer.js

@@ -43,13 +43,17 @@ const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const chalk_1 = __importDefault(require("chalk"));
 const simple_git_1 = __importDefault(require("simple-git"));
+const logger_1 = require("./utils/logger");
 const config_1 = require("./config");
 const detective_1 = require("./detective");
 const gemini_embedding_1 = require("./gemini-embedding");
 const mock_llm_1 = require("./mock-llm");
 const dashboard_1 = require("./dashboard");
+const session_1 = require("./session");
+const critique_1 = require("./core/critique");
 const llamaindex_1 = require("llamaindex");
-const google = (0, google_1.createGoogleGenerativeAI)({ apiKey: process.env.GOOGLE_API_KEY });
+const geminiKey = process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY;
+const google = (0, google_1.createGoogleGenerativeAI)({ apiKey: geminiKey });
 const groq = (0, groq_1.createGroq)({ apiKey: process.env.GROQ_API_KEY });
 const embedModel = new gemini_embedding_1.GeminiEmbedding();
 const llm = new mock_llm_1.MockLLM();
@@ -87,6 +91,33 @@ function chunkDiffByFile(diff) {
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
+/**
+ * Filter issues by confidence threshold and log what was removed
+ */
+function filterByConfidence(findings) {
+    const threshold = config_1.Config.CONFIDENCE_THRESHOLD;
+    let removedCount = 0;
+    const filtered = findings.map(finding => {
+        const validIssues = finding.issues.filter(issue => {
+            const confidence = issue.confidenceScore ?? 5; // Default to high if not specified
+            if (confidence < threshold) {
+                removedCount++;
+                logger_1.Logger.info(chalk_1.default.dim(`   ⚡ Low confidence (${confidence}): "${issue.title}" - filtered out`));
+                return false;
+            }
+            return true;
+        });
+        return {
+            ...finding,
+            issues: validIssues,
+            severity: validIssues.length === 0 ? 'LGTM' : finding.severity
+        };
+    });
+    if (removedCount > 0) {
+        logger_1.Logger.info(chalk_1.default.blue(`\n   📊 Confidence Filter: ${removedCount} low-confidence issue(s) removed\n`));
+    }
+    return filtered;
+}
 function parseReviewResponse(text) {
     try {
         // Try to extract JSON from the response
@@ -124,30 +155,32 @@ function parseReviewResponse(text) {
 }
 // --- Main ---
 async function main() {
-    console.log(chalk_1.default.blue("🕵️  J-Star Reviewer: Analyzing your changes...\n"));
+    // Initialize logger mode based on CLI flags
+    logger_1.Logger.init();
+    logger_1.Logger.info(chalk_1.default.blue("🕵️  J-Star Reviewer: Analyzing your changes...\n"));
     // 0. Environment Validation
-    if (!process.env.GOOGLE_API_KEY || !process.env.GROQ_API_KEY) {
-        console.error(chalk_1.default.red("❌ Missing API Keys!"));
-        console.log(chalk_1.default.yellow("\nPlease ensure you have a .env.local file with:"));
-        console.log(chalk_1.default.white("- GOOGLE_API_KEY"));
-        console.log(chalk_1.default.white("- GROQ_API_KEY"));
-        console.log(chalk_1.default.white("\nCheck .env.example for a template.\n"));
+    if (!geminiKey || !process.env.GROQ_API_KEY) {
+        logger_1.Logger.error(chalk_1.default.red("❌ Missing API Keys!"));
+        logger_1.Logger.info(chalk_1.default.yellow("\nPlease ensure you have a .env.local file with:"));
+        logger_1.Logger.info(chalk_1.default.white("- GEMINI_API_KEY (or GOOGLE_API_KEY)"));
+        logger_1.Logger.info(chalk_1.default.white("- GROQ_API_KEY"));
+        logger_1.Logger.info(chalk_1.default.white("\nCheck .env.example for a template.\n"));
         return;
     }
     // 1. Detective
-    console.log(chalk_1.default.blue("🔎 Running Detective Engine..."));
+    logger_1.Logger.info(chalk_1.default.blue("🔎 Running Detective Engine..."));
     const detective = new detective_1.Detective(SOURCE_DIR);
     await detective.scan();
     detective.report();
     // 1. Get the Diff
     const diff = await git.diff(["--staged"]);
     if (!diff) {
-        console.log(chalk_1.default.green("\n✅ No staged changes to review. (Did you 'git add'?)"));
+        logger_1.Logger.info(chalk_1.default.green("\n✅ No staged changes to review. (Did you 'git add'?)"));
         return;
     }
     // 2. Load the Brain
     if (!fs.existsSync(STORAGE_DIR)) {
-        console.error(chalk_1.default.red("❌ Local Brain not found. Run 'pnpm run index:init' first."));
+        logger_1.Logger.error(chalk_1.default.red("❌ Local Brain not found. Run 'pnpm run index:init' first."));
         return;
     }
     const storageContext = await (0, llamaindex_1.storageContextFromDefaults)({ persistDir: STORAGE_DIR });
@@ -159,13 +192,13 @@ async function main() {
         .join(" ").slice(0, 300) || "general context";
     const contextNodes = await retriever.retrieve(keywords);
     const relatedContext = contextNodes.map(n => n.node.getContent(llamaindex_1.MetadataMode.NONE).slice(0, 1500)).join("\n");
-    console.log(chalk_1.default.yellow(`\n🧠 Found ${contextNodes.length} context chunk.`));
+    logger_1.Logger.info(chalk_1.default.yellow(`\n🧠 Found ${contextNodes.length} context chunk.`));
     // 4. Chunk the Diff
     const fileChunks = chunkDiffByFile(diff);
     const totalTokens = estimateTokens(diff);
-    console.log(chalk_1.default.dim(`   Total diff: ~${totalTokens} tokens across ${fileChunks.length} files.`));
-    // 5. Structured JSON Prompt
-    const systemPrompt = `You are J-Star, a Senior Code Reviewer. Be direct and professional.
+    logger_1.Logger.info(chalk_1.default.dim(`   Total diff: ~${totalTokens} tokens across ${fileChunks.length} files.`));
+    // 5. Structured JSON Prompt (Conservative)
+    const systemPrompt = `You are J-Star, a Senior Code Reviewer. Be CONSERVATIVE and PRECISE.
 
 Analyze the Git Diff and return a JSON response with this EXACT structure:
 {
@@ -175,7 +208,8 @@ Analyze the Git Diff and return a JSON response with this EXACT structure:
       "title": "Short issue title",
       "description": "Detailed description of the problem",
       "line": 42,
-      "fixPrompt": "A specific prompt an AI can use to fix this issue"
+      "fixPrompt": "A specific prompt an AI can use to fix this issue",
+      "confidenceScore": 5
     }
   ]
 }
@@ -186,29 +220,39 @@ SEVERITY GUIDE:
 - P2_MEDIUM: Code quality, missing types, cleanup needed
 - LGTM: No issues found (return empty issues array)
 
-IMPORTANT: 
-- Return ONLY valid JSON, no markdown or explanation
-- Each issue MUST have a fixPrompt that explains exactly how to fix it
-- If the file is clean, return {"severity": "LGTM", "issues": []}
+CONFIDENCE SCORE (1-5) - BE HONEST:
+- 5: Absolutely certain. The bug is obvious in the diff.
+- 4: Very likely. Clear code smell or anti-pattern.
+- 3: Probable issue, might be missing context.
+- 2: Unsure, could be intentional.
+- 1: Speculation, likely false positive.
+
+CRITICAL RULES:
+1. Only flag issues you are HIGHLY confident about (4-5).
+2. Test mocks, stubs, and intentional patterns are NOT bugs.
+3. If the code looks intentional or well-handled, it's probably fine.
+4. When in doubt, lean towards LGTM.
+5. Return ONLY valid JSON, no markdown.
+6. If the file is clean: {"severity": "LGTM", "issues": []}
 
 Context: ${relatedContext.slice(0, 800)}`;
     const findings = [];
     let chunkIndex = 0;
     let skippedCount = 0;
-    console.log(chalk_1.default.blue("\n⚖️  Sending to Judge...\n"));
+    logger_1.Logger.info(chalk_1.default.blue("\n⚖️  Sending to Judge...\n"));
     for (const chunk of fileChunks) {
         chunkIndex++;
         const fileName = chunk.match(/diff --git a\/(.+?) /)?.[1] || `Chunk ${chunkIndex}`;
         // Skip excluded files
         if (shouldSkipFile(fileName)) {
-            console.log(chalk_1.default.dim(`   ⏭️  Skipping ${fileName} (excluded)`));
+            logger_1.Logger.info(chalk_1.default.dim(`   ⏭️  Skipping ${fileName} (excluded)`));
             skippedCount++;
             continue;
         }
         const chunkTokens = estimateTokens(chunk) + estimateTokens(systemPrompt);
         // Skip huge files
         if (chunkTokens > MAX_TOKENS_PER_REQUEST) {
-            console.log(chalk_1.default.yellow(`   ⚠️  Skipping ${fileName} (too large: ~${chunkTokens} tokens)`));
+            logger_1.Logger.info(chalk_1.default.yellow(`   ⚠️  Skipping ${fileName} (too large: ~${chunkTokens} tokens)`));
             findings.push({
                 file: fileName,
                 severity: config_1.Config.DEFAULT_SEVERITY,
@@ -220,7 +264,7 @@ Context: ${relatedContext.slice(0, 800)}`;
             });
             continue;
         }
-        process.stdout.write(chalk_1.default.dim(`   📄 ${fileName}...`));
+        logger_1.Logger.progress(chalk_1.default.dim(`   📄 ${fileName}...`));
         try {
             const { text } = await (0, ai_1.generateText)({
                 model: groq(MODEL_NAME),
@@ -237,10 +281,10 @@ Context: ${relatedContext.slice(0, 800)}`;
             const emoji = response.severity === 'LGTM' ? '✅' :
                 response.severity === 'P0_CRITICAL' ? '🛑' :
                     response.severity === 'P1_HIGH' ? '⚠️' : '📝';
-            console.log(` ${emoji}`);
+            logger_1.Logger.info(` ${emoji}`);
         }
         catch (error) {
-            console.log(chalk_1.default.red(` ❌ (${error.message.slice(0, 50)})`));
+            logger_1.Logger.info(chalk_1.default.red(` ❌ (${error.message.slice(0, 50)})`));
             findings.push({
                 file: fileName,
                 severity: config_1.Config.DEFAULT_SEVERITY,
@@ -256,22 +300,29 @@ Context: ${relatedContext.slice(0, 800)}`;
             await sleep(DELAY_BETWEEN_CHUNKS_MS);
         }
     }
-    // 6. Build Dashboard Report
+    // 6. Confidence Filtering
+    logger_1.Logger.info(chalk_1.default.blue("\n🎯 Filtering by Confidence...\n"));
+    let filteredFindings = filterByConfidence(findings);
+    // 7. Self-Critique Pass (if enabled)
+    if (config_1.Config.ENABLE_SELF_CRITIQUE) {
+        filteredFindings = await (0, critique_1.critiqueFindings)(filteredFindings, diff);
+    }
+    // 8. Build Dashboard Report
     const metrics = {
         filesScanned: fileChunks.length - skippedCount,
         totalTokens,
-        violations: findings.reduce((sum, f) => sum + f.issues.length, 0),
-        critical: findings.filter(f => f.severity === 'P0_CRITICAL').length,
-        high: findings.filter(f => f.severity === 'P1_HIGH').length,
-        medium: findings.filter(f => f.severity === 'P2_MEDIUM').length,
-        lgtm: findings.filter(f => f.severity === 'LGTM').length,
+        violations: filteredFindings.reduce((sum, f) => sum + f.issues.length, 0),
+        critical: filteredFindings.filter(f => f.severity === 'P0_CRITICAL').length,
+        high: filteredFindings.filter(f => f.severity === 'P1_HIGH').length,
+        medium: filteredFindings.filter(f => f.severity === 'P2_MEDIUM').length,
+        lgtm: filteredFindings.filter(f => f.severity === 'LGTM').length,
     };
     const report = {
         date: new Date().toISOString().split('T')[0],
         reviewer: 'Detective Engine & Judge',
         status: (0, dashboard_1.determineStatus)(metrics),
         metrics,
-        findings,
+        findings: filteredFindings,
         recommendedAction: (0, dashboard_1.generateRecommendation)(metrics)
     };
     // 7. Render and Save Dashboard
@@ -279,18 +330,63 @@ Context: ${relatedContext.slice(0, 800)}`;
     // Ensure .jstar directory exists
     fs.mkdirSync(path.dirname(OUTPUT_FILE), { recursive: true });
     fs.writeFileSync(OUTPUT_FILE, dashboard);
-    console.log("\n" + chalk_1.default.bold.green("📊 DASHBOARD GENERATED"));
-    console.log(chalk_1.default.dim(`   Saved to: ${OUTPUT_FILE}`));
-    console.log("\n" + chalk_1.default.bold.white("─".repeat(50)));
+    // Save Session State for "jstar chat"
+    const SESSION_FILE = path.join(process.cwd(), ".jstar", "session.json");
+    fs.writeFileSync(SESSION_FILE, JSON.stringify({
+        date: report.date,
+        findings: report.findings,
+        metrics: report.metrics
+    }, null, 2));
+    logger_1.Logger.info("\n" + chalk_1.default.bold.green("📊 DASHBOARD GENERATED"));
+    logger_1.Logger.info(chalk_1.default.dim(`   Saved to: ${OUTPUT_FILE}`));
+    logger_1.Logger.info("\n" + chalk_1.default.bold.white("─".repeat(50)));
     // Print summary to console
     const statusEmoji = report.status === 'APPROVED' ? '🟢' :
         report.status === 'NEEDS_REVIEW' ? '🟡' : '🔴';
-    console.log(`\n${statusEmoji} Status: ${report.status.replace('_', ' ')}`);
-    console.log(`   🛑 Critical: ${metrics.critical}`);
-    console.log(`   ⚠️  High: ${metrics.high}`);
-    console.log(`   📝 Medium: ${metrics.medium}`);
-    console.log(`   ✅ LGTM: ${metrics.lgtm}`);
-    console.log(`\n💡 ${report.recommendedAction}`);
-    console.log(chalk_1.default.dim(`\n📄 Full report: ${OUTPUT_FILE}`));
+    logger_1.Logger.info(`\n${statusEmoji} Status: ${report.status.replace('_', ' ')}`);
+    logger_1.Logger.info(`   🛑 Critical: ${metrics.critical}`);
+    logger_1.Logger.info(`   ⚠️  High: ${metrics.high}`);
+    logger_1.Logger.info(`   📝 Medium: ${metrics.medium}`);
+    logger_1.Logger.info(`   ✅ LGTM: ${metrics.lgtm}`);
+    logger_1.Logger.info(`\n💡 ${report.recommendedAction}`);
+    logger_1.Logger.info(chalk_1.default.dim(`\n📄 Full report: ${OUTPUT_FILE}`));
+    // 8. Interactive Session OR JSON Output
+    if (logger_1.Logger.isHeadless()) {
+        // In JSON mode: output report to stdout and skip interactive session
+        logger_1.Logger.json(report);
+    }
+    else {
+        // Normal TUI mode: start interactive session
+        const { updatedFindings, hasUpdates } = await (0, session_1.startInteractiveSession)(findings, index);
+        if (hasUpdates) {
+            logger_1.Logger.info(chalk_1.default.blue("\n🔄 Updating Dashboard with session changes..."));
+            // Recalculate metrics
+            const newMetrics = {
+                filesScanned: fileChunks.length - skippedCount,
+                totalTokens,
+                violations: updatedFindings.reduce((sum, f) => sum + f.issues.length, 0),
+                critical: updatedFindings.filter(f => f.severity === 'P0_CRITICAL').length,
+                high: updatedFindings.filter(f => f.severity === 'P1_HIGH').length,
+                medium: updatedFindings.filter(f => f.severity === 'P2_MEDIUM').length,
+                lgtm: updatedFindings.filter(f => f.severity === 'LGTM').length,
+            };
+            const newReport = {
+                ...report, // Keep date/reviewer
+                metrics: newMetrics,
+                findings: updatedFindings,
+                status: (0, dashboard_1.determineStatus)(newMetrics),
+                recommendedAction: (0, dashboard_1.generateRecommendation)(newMetrics)
+            };
+            const newDashboard = (0, dashboard_1.renderDashboard)(newReport);
+            fs.writeFileSync(OUTPUT_FILE, newDashboard);
+            // Also update session file with new findings
+            fs.writeFileSync(SESSION_FILE, JSON.stringify({
+                date: newReport.date,
+                findings: newReport.findings,
+                metrics: newReport.metrics
+            }, null, 2));
+            logger_1.Logger.info(chalk_1.default.bold.green("📊 DASHBOARD UPDATED"));
+        }
+    }
 }
 main().catch(console.error);

package/dist/scripts/session.js

@@ -0,0 +1,273 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startInteractiveSession = startInteractiveSession;
+exports.startHeadlessSession = startHeadlessSession;
+const interaction_1 = require("./ui/interaction");
+const debate_1 = require("./core/debate");
+const logger_1 = require("./utils/logger");
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = __importDefault(require("prompts"));
+const readline = __importStar(require("readline"));
+async function startInteractiveSession(findings, index) {
+    // Deep clone to track local state without mutating original immediately (though we return updated findings)
+    const interactiveFindings = JSON.parse(JSON.stringify(findings));
+    let hasUpdates = false;
+    let active = true;
+    if (interactiveFindings.length === 0 || interactiveFindings.every(f => f.issues.length === 0)) {
+        return { updatedFindings: interactiveFindings, hasUpdates: false };
+    }
+    console.log(chalk_1.default.bold.magenta("\n🗣️  Interactive Review Session"));
+    console.log(chalk_1.default.dim("   Use arrow keys to navigate. Select an issue to debate."));
+    while (active) {
+        // Re-calculate choices every loop to reflect status changes
+        // Flatten
+        const flatIssues = [];
+        interactiveFindings.forEach((f, fIdx) => {
+            f.issues.forEach((i, iIdx) => {
+                flatIssues.push({
+                    issue: i,
+                    fileIndex: fIdx,
+                    issueIndex: iIdx,
+                    file: f.file
+                });
+            });
+        });
+        const choices = flatIssues.map((item, idx) => {
+            const i = item.issue;
+            const statusIcon = i.status === 'resolved' ? '✅ ' : i.status === 'ignored' ? '🗑️ ' : '';
+            return {
+                title: `${statusIcon}${i.confidenceScore ? `[${i.confidenceScore}/5] ` : ''}${i.title} ${chalk_1.default.dim(`(${item.file})`)}`,
+                value: idx,
+                description: i.status ? `Marked as ${i.status}` : i.description.slice(0, 80)
+            };
+        });
+        choices.push({ title: '🚪 Finish Review', value: -1, description: 'Exit and save report' });
+        const { selectedIdx } = await (0, prompts_1.default)({
+            type: 'select',
+            name: 'selectedIdx',
+            message: 'Select an issue:',
+            choices: choices,
+            initial: 0
+        });
+        if (selectedIdx === undefined || selectedIdx === -1) {
+            active = false;
+            break;
+        }
+        const selected = flatIssues[selectedIdx];
+        const { issue, file } = selected;
+        // Show Details
+        console.log(chalk_1.default.cyan(`\nTitle: ${issue.title}`));
+        console.log(chalk_1.default.white(issue.description));
+        console.log(chalk_1.default.dim(`File: ${file}`));
+        if (issue.confidenceScore)
+            console.log(chalk_1.default.yellow(`Confidence: ${issue.confidenceScore}/5`));
+        if (issue.status)
+            console.log(chalk_1.default.green(`Status: ${issue.status}`));
+        // Action Menu
+        const action = await (0, interaction_1.showActionMenu)(issue.title);
+        if (action === 'discuss') {
+            const argument = await (0, interaction_1.askForArgument)();
+            const result = await (0, debate_1.debateIssue)(issue.title, issue.description, file, argument, index);
+            console.log(chalk_1.default.yellow(`\n🤖 Bot: ${result.text}`));
+            if (result.severity === 'LGTM') {
+                console.log(chalk_1.default.green("✅ Issue withdrawn by AI!"));
+                // Direct update to our state
+                interactiveFindings[selected.fileIndex].issues[selected.issueIndex].status = 'resolved';
+                hasUpdates = true;
+            }
+        }
+        else if (action === 'ignore') {
+            console.log(chalk_1.default.dim('Issue ignored locally.'));
+            interactiveFindings[selected.fileIndex].issues[selected.issueIndex].status = 'ignored';
+            hasUpdates = true;
+        }
+        else if (action === 'accept') {
+            console.log(chalk_1.default.green('Issue accepted.'));
+        }
+        else if (action === 'exit') {
+            active = false;
+        }
+    }
+    // Filter out resolved/ignored issues for the final report
+    const finalFindings = interactiveFindings.map(f => ({
+        ...f,
+        issues: f.issues.filter(i => i.status !== 'resolved' && i.status !== 'ignored')
+    })).filter(f => f.issues.length > 0);
+    return { updatedFindings: finalFindings, hasUpdates };
+}
+/**
+ * Flatten findings into a simple array for headless mode
+ */
+function flattenIssues(findings) {
+    const flat = [];
+    findings.forEach((f, fIdx) => {
+        f.issues.forEach((i, iIdx) => {
+            flat.push({
+                id: flat.length,
+                title: i.title,
+                description: i.description,
+                file: f.file,
+                confidenceScore: i.confidenceScore,
+                status: i.status,
+                fileIndex: fIdx,
+                issueIndex: iIdx
+            });
+        });
+    });
+    return flat;
+}
+/**
+ * Headless session for AI agents and CI/CD.
+ *
+ * Protocol:
+ * - Input (stdin): JSON commands, one per line
+ *   { "action": "list" }
+ *   { "action": "debate", "issueId": 0, "argument": "This is intentional" }
+ *   { "action": "ignore", "issueId": 0 }
+ *   { "action": "accept", "issueId": 0 }
+ *   { "action": "exit" }
+ *
+ * - Output (stdout): JSON events, one per line
+ *   { "type": "ready", "issues": [...] }
+ *   { "type": "list", "issues": [...] }
+ *   { "type": "response", "issueId": 0, "text": "...", "verdict": "LGTM" | "STANDS" }
+ *   { "type": "update", "issueId": 0, "status": "ignored" | "resolved" | "accepted" }
+ *   { "type": "error", "message": "..." }
+ *   { "type": "done", "hasUpdates": true, "updatedFindings": [...] }
+ */
+async function startHeadlessSession(findings, index) {
+    // Deep clone to track state
+    const sessionFindings = JSON.parse(JSON.stringify(findings));
+    let hasUpdates = false;
+    // Emit ready event with all issues
+    const issues = flattenIssues(sessionFindings);
+    logger_1.Logger.json({ type: 'ready', issues });
+    // Create readline interface for stdin
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: false
+    });
+    // Process commands
+    for await (const line of rl) {
+        if (!line.trim())
+            continue;
+        let cmd;
+        try {
+            cmd = JSON.parse(line);
+        }
+        catch (e) {
+            logger_1.Logger.json({ type: 'error', message: 'Invalid JSON command' });
+            continue;
+        }
+        const currentIssues = flattenIssues(sessionFindings);
+        switch (cmd.action) {
+            case 'list':
+                logger_1.Logger.json({ type: 'list', issues: currentIssues });
+                break;
+            case 'debate':
+                if (cmd.issueId === undefined || !cmd.argument) {
+                    logger_1.Logger.json({ type: 'error', message: 'debate requires issueId and argument' });
+                    break;
+                }
+                const debateTarget = currentIssues.find(i => i.id === cmd.issueId);
+                if (!debateTarget) {
+                    logger_1.Logger.json({ type: 'error', message: `Issue ${cmd.issueId} not found` });
+                    break;
+                }
+                try {
+                    const result = await (0, debate_1.debateIssue)(debateTarget.title, debateTarget.description, debateTarget.file, cmd.argument, index);
+                    const verdict = result.severity === 'LGTM' ? 'LGTM' : 'STANDS';
+                    logger_1.Logger.json({
+                        type: 'response',
+                        issueId: cmd.issueId,
+                        text: result.text,
+                        verdict
+                    });
+                    if (result.severity === 'LGTM') {
+                        sessionFindings[debateTarget.fileIndex].issues[debateTarget.issueIndex].status = 'resolved';
+                        hasUpdates = true;
+                        logger_1.Logger.json({ type: 'update', issueId: cmd.issueId, status: 'resolved' });
+                    }
+                }
+                catch (e) {
+                    logger_1.Logger.json({ type: 'error', message: e.message });
+                }
+                break;
+            case 'ignore':
+                if (cmd.issueId === undefined) {
+                    logger_1.Logger.json({ type: 'error', message: 'ignore requires issueId' });
+                    break;
+                }
+                const ignoreTarget = currentIssues.find(i => i.id === cmd.issueId);
+                if (!ignoreTarget) {
+                    logger_1.Logger.json({ type: 'error', message: `Issue ${cmd.issueId} not found` });
+                    break;
+                }
+                sessionFindings[ignoreTarget.fileIndex].issues[ignoreTarget.issueIndex].status = 'ignored';
+                hasUpdates = true;
+                logger_1.Logger.json({ type: 'update', issueId: cmd.issueId, status: 'ignored' });
+                break;
+            case 'accept':
+                if (cmd.issueId === undefined) {
+                    logger_1.Logger.json({ type: 'error', message: 'accept requires issueId' });
+                    break;
+                }
+                logger_1.Logger.json({ type: 'update', issueId: cmd.issueId, status: 'accepted' });
+                break;
+            case 'exit':
+                // Filter out resolved/ignored for final report
+                const finalFindings = sessionFindings.map(f => ({
+                    ...f,
+                    issues: f.issues.filter(i => i.status !== 'resolved' && i.status !== 'ignored')
+                })).filter(f => f.issues.length > 0);
+                logger_1.Logger.json({ type: 'done', hasUpdates, updatedFindings: finalFindings });
+                rl.close();
+                return { updatedFindings: finalFindings, hasUpdates };
+            default:
+                logger_1.Logger.json({ type: 'error', message: `Unknown action: ${cmd.action}` });
+        }
+    }
+    // If stdin closes without exit command, still return
+    const finalFindings = sessionFindings.map(f => ({
+        ...f,
+        issues: f.issues.filter(i => i.status !== 'resolved' && i.status !== 'ignored')
+    })).filter(f => f.issues.length > 0);
+    return { updatedFindings: finalFindings, hasUpdates };
+}

package/dist/scripts/ui/interaction.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showActionMenu = showActionMenu;
+exports.askForArgument = askForArgument;
+const prompts_1 = __importDefault(require("prompts"));
+const chalk_1 = __importDefault(require("chalk"));
+async function showActionMenu(issueTitle) {
+    try {
+        const response = await (0, prompts_1.default)({
+            type: 'select',
+            name: 'action',
+            message: `Action for: ${chalk_1.default.yellow(issueTitle)}`,
+            choices: [
+                { title: '✅ Accept', value: 'accept', description: 'Mark as valid issue' },
+                { title: '💬 Discuss', value: 'discuss', description: 'Debate this finding with AI' },
+                { title: '❌ Ignore', value: 'ignore', description: 'Discard this issue' },
+                { title: '🚪 Exit', value: 'exit', description: 'Stop review session' }
+            ],
+            initial: 0
+        });
+        return response.action || 'exit';
+    }
+    catch (e) {
+        return 'exit';
+    }
+}
+async function askForArgument() {
+    try {
+        const response = await (0, prompts_1.default)({
+            type: 'text',
+            name: 'argument',
+            message: 'Your argument (e.g., "Check utils.ts, logic is handled there"):',
+            validate: value => value.length < 5 ? 'Please provide more context' : true
+        });
+        return response.argument || '';
+    }
+    catch (e) {
+        return '';
+    }
+}