jstar-reviewer 2.1.4 → 2.2.0

package/bin/jstar.js

@@ -29,7 +29,7 @@ function log(msg) {
 
 function printHelp() {
     log(`
-${COLORS.bold}🌟 J-Star Reviewer v2${COLORS.reset}
+${COLORS.bold}🌟 J-Star Reviewer v2.2.0${COLORS.reset}
 
 ${COLORS.dim}AI-powered code review with local embeddings${COLORS.reset}
 
@@ -39,8 +39,13 @@ ${COLORS.bold}USAGE:${COLORS.reset}
 ${COLORS.bold}COMMANDS:${COLORS.reset}
   ${COLORS.green}init${COLORS.reset}      Index the current codebase (build the brain)
   ${COLORS.green}review${COLORS.reset}    Review staged git changes
+  ${COLORS.green}chat${COLORS.reset}      Resume an interactive session from the last review
   ${COLORS.green}setup${COLORS.reset}     Create .env.example and .jstar/ in current directory
 
+${COLORS.bold}OPTIONS:${COLORS.reset}
+  ${COLORS.yellow}--json${COLORS.reset}      Output machine-readable JSON (for CI/CD)
+  ${COLORS.yellow}--headless${COLORS.reset}  Enable stdin/stdout protocol (for AI agents)
+
 ${COLORS.bold}EXAMPLES:${COLORS.reset}
   ${COLORS.dim}# First time setup${COLORS.reset}
   jstar init
@@ -49,6 +54,9 @@ ${COLORS.bold}EXAMPLES:${COLORS.reset}
   git add .
   jstar review
 
+  ${COLORS.dim}# JSON output for CI${COLORS.reset}
+  jstar review --json > report.json
+
 ${COLORS.bold}ENVIRONMENT:${COLORS.reset}
   GEMINI_API_KEY    Required for Gemini embeddings (or GOOGLE_API_KEY)
   GROQ_API_KEY      Required for Groq LLM reviews
@@ -214,6 +222,9 @@ switch (command) {
     case 'review':
         runScript('reviewer.ts');
         break;
+    case 'chat':
+        runScript('chat.ts');
+        break;
     case 'setup':
         createSetupFiles();
         break;

package/dist/scripts/chat.js

@@ -0,0 +1,150 @@
+"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 });
+const session_1 = require("./session");
+const llamaindex_1 = require("llamaindex");
+const gemini_embedding_1 = require("./gemini-embedding");
+const mock_llm_1 = require("./mock-llm");
+const logger_1 = require("./utils/logger");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const chalk_1 = __importDefault(require("chalk"));
+const dashboard_1 = require("./dashboard");
+const STORAGE_DIR = path.join(process.cwd(), ".jstar", "storage");
+const SESSION_FILE = path.join(process.cwd(), ".jstar", "session.json");
+const OUTPUT_FILE = path.join(process.cwd(), ".jstar", "last-review.md");
+const embedModel = new gemini_embedding_1.GeminiEmbedding();
+const llm = new mock_llm_1.MockLLM();
+const serviceContext = (0, llamaindex_1.serviceContextFromDefaults)({ embedModel, llm: llm });
+async function loadSession() {
+    try {
+        const content = fs.readFileSync(SESSION_FILE, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            return null; // File doesn't exist
+        }
+        logger_1.Logger.error(`Failed to load session: ${e.message}`);
+        return null;
+    }
+}
+async function main() {
+    // Initialize logger mode
+    logger_1.Logger.init();
+    logger_1.Logger.info(chalk_1.default.bold.magenta("\n💬 J-Star Chat: Resuming Session...\n"));
+    // 1. Load Session
+    const session = await loadSession();
+    if (!session) {
+        logger_1.Logger.error(chalk_1.default.red("❌ No active session found."));
+        logger_1.Logger.info(chalk_1.default.yellow("Run 'jstar review' first to analyze the codebase."));
+        return;
+    }
+    logger_1.Logger.info(chalk_1.default.dim(`   📅 Loaded session from: ${session.date}`));
+    logger_1.Logger.info(chalk_1.default.dim(`   🔍 Loaded ${session.findings.reduce((acc, f) => acc + f.issues.length, 0)} issues.`));
+    // 2. Load Brain (Fast)
+    if (!fs.existsSync(STORAGE_DIR)) {
+        logger_1.Logger.error(chalk_1.default.red("❌ Local Brain not found. Run 'pnpm index:init' first."));
+        return;
+    }
+    const storageContext = await (0, llamaindex_1.storageContextFromDefaults)({ persistDir: STORAGE_DIR });
+    const index = await llamaindex_1.VectorStoreIndex.init({ storageContext, serviceContext });
+    // 3. Start Chat (Headless or Interactive)
+    let updatedFindings;
+    let hasUpdates;
+    if (logger_1.Logger.isHeadless()) {
+        // Headless mode: stdin/stdout JSON protocol
+        const result = await (0, session_1.startHeadlessSession)(session.findings, index);
+        updatedFindings = result.updatedFindings;
+        hasUpdates = result.hasUpdates;
+    }
+    else {
+        // Normal TUI mode
+        const result = await (0, session_1.startInteractiveSession)(session.findings, index);
+        updatedFindings = result.updatedFindings;
+        hasUpdates = result.hasUpdates;
+    }
+    // 4. Update Session & Report if changed
+    if (hasUpdates) {
+        logger_1.Logger.info(chalk_1.default.blue("\n🔄 Updating Session & Dashboard..."));
+        // Recalculate metrics based on new findings
+        const newMetrics = {
+            ...session.metrics, // keep files/tokens same
+            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,
+        };
+        // Save Session
+        const newSession = {
+            date: new Date().toISOString().split('T')[0],
+            findings: updatedFindings,
+            metrics: newMetrics
+        };
+        try {
+            fs.writeFileSync(SESSION_FILE, JSON.stringify(newSession, null, 2));
+        }
+        catch (err) {
+            logger_1.Logger.error(`Failed to save session: ${err.message}`);
+            return;
+        }
+        // Save Dashboard
+        const report = {
+            date: newSession.date,
+            reviewer: 'J-Star Chat',
+            status: (0, dashboard_1.determineStatus)(newMetrics),
+            metrics: newMetrics,
+            findings: updatedFindings,
+            recommendedAction: (0, dashboard_1.generateRecommendation)(newMetrics)
+        };
+        const dashboard = (0, dashboard_1.renderDashboard)(report);
+        try {
+            fs.writeFileSync(OUTPUT_FILE, dashboard);
+        }
+        catch (err) {
+            logger_1.Logger.error(`Failed to save dashboard: ${err.message}`);
+            return;
+        }
+        logger_1.Logger.info(chalk_1.default.bold.green("✅ Saved."));
+    }
+    else {
+        logger_1.Logger.info(chalk_1.default.dim("   No changes made."));
+    }
+}
+main().catch(console.error);

package/dist/scripts/config.js

@@ -86,8 +86,12 @@ dotenv_1.default.config({ path: path.join(cwd, ".env") });
 const DEFAULT_MODEL = "moonshotai/kimi-k2-instruct-0905";
 exports.Config = {
     MODEL_NAME: process.env.REVIEW_MODEL_NAME || DEFAULT_MODEL,
+    CRITIQUE_MODEL_NAME: process.env.CRITIQUE_MODEL_NAME || process.env.REVIEW_MODEL_NAME || DEFAULT_MODEL,
     DEFAULT_SEVERITY: 'P2_MEDIUM',
     THRESHOLDS: {
         MEDIUM: 5
-    }
+    },
+    // Smart Review Settings
+    CONFIDENCE_THRESHOLD: 3, // Minimum confidence (1-5) to include an issue
+    ENABLE_SELF_CRITIQUE: true, // Enable second-pass validation
 };

package/dist/scripts/core/critique.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * Self-Critique Module
+ * Second-pass validation to filter out false positives
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.critiqueFindings = critiqueFindings;
+const ai_1 = require("ai");
+const groq_1 = require("@ai-sdk/groq");
+const chalk_1 = __importDefault(require("chalk"));
+const logger_1 = require("../utils/logger");
+const config_1 = require("../config");
+const groq = (0, groq_1.createGroq)({ apiKey: process.env.GROQ_API_KEY });
+/**
+ * Runs a self-critique pass on the initial findings.
+ * Returns filtered findings with only validated issues.
+ */
+async function critiqueFindings(findings, diff) {
+    // Collect all issues across all files for batch critique
+    const allIssues = [];
+    findings.forEach((f, fIdx) => {
+        f.issues.forEach((issue, iIdx) => {
+            allIssues.push({ file: f.file, issue, index: fIdx * 1000 + iIdx });
+        });
+    });
+    if (allIssues.length === 0) {
+        return findings;
+    }
+    logger_1.Logger.info(chalk_1.default.blue("\n🔍 Self-Critique Pass: Validating findings...\n"));
+    // Build the critique prompt
+    const issueList = allIssues.map((item, idx) => `[${idx}] File: ${item.file}\n    Title: ${item.issue.title}\n    Description: ${item.issue.description}`).join("\n\n");
+    const systemPrompt = `You are a code review validator. Your job is to filter out FALSE POSITIVES.
+
+For each issue below, decide:
+- VALID: This is a real problem that should be reported
+- FALSE_POSITIVE: This is NOT a real issue (test mock, intentional pattern, already handled, etc.)
+- NEEDS_CONTEXT: Can't determine without more code context (treat as valid)
+
+Return JSON with this structure:
+{
+  "results": [
+    { "issueTitle": "...", "verdict": "VALID" | "FALSE_POSITIVE" | "NEEDS_CONTEXT", "reason": "..." }
+  ]
+}
+
+IMPORTANT:
+- Be SKEPTICAL. If the code looks intentional, it's probably not a bug.
+- Test files, mocks, and stubs are NOT bugs.
+- "Missing error handling" in utility modules may be intentional.
+- Return ONLY valid JSON.`;
+    const userPrompt = `ORIGINAL DIFF:
+\`\`\`
+${diff.slice(0, 4000)}
+\`\`\`
+
+ISSUES TO VALIDATE:
+${issueList}`;
+    try {
+        const { text } = await (0, ai_1.generateText)({
+            model: groq(config_1.Config.CRITIQUE_MODEL_NAME),
+            system: systemPrompt,
+            prompt: userPrompt,
+            temperature: 0.1,
+        });
+        // Parse critique response
+        const jsonMatch = text.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            logger_1.Logger.warn(chalk_1.default.yellow("   ⚠️ Could not parse critique response, keeping all issues"));
+            return findings;
+        }
+        let response;
+        try {
+            const parsed = JSON.parse(jsonMatch[0]);
+            // Validate structure
+            if (!parsed || !Array.isArray(parsed.results)) {
+                throw new Error("Invalid response structure");
+            }
+            response = parsed;
+        }
+        catch (parseError) {
+            logger_1.Logger.warn(chalk_1.default.yellow("   ⚠️ Invalid JSON from critique, keeping all issues"));
+            return findings;
+        }
+        // Build a map of verdicts by title
+        const verdictMap = new Map();
+        for (const result of response.results) {
+            verdictMap.set(result.issueTitle.toLowerCase(), result);
+        }
+        // Filter findings
+        const filteredFindings = [];
+        let removedCount = 0;
+        for (const finding of findings) {
+            const validIssues = [];
+            for (const issue of finding.issues) {
+                const verdict = verdictMap.get(issue.title.toLowerCase());
+                if (verdict?.verdict === 'FALSE_POSITIVE') {
+                    removedCount++;
+                    logger_1.Logger.info(chalk_1.default.dim(`   ❌ Removed: "${issue.title}" (${verdict.reason})`));
+                }
+                else {
+                    validIssues.push(issue);
+                    if (verdict?.verdict === 'VALID') {
+                        logger_1.Logger.info(chalk_1.default.green(`   ✓ Kept: "${issue.title}"`));
+                    }
+                }
+            }
+            if (validIssues.length > 0) {
+                filteredFindings.push({
+                    ...finding,
+                    issues: validIssues,
+                    // Upgrade to LGTM if no issues remain? No, keep severity for record
+                });
+            }
+            else if (finding.issues.length > 0) {
+                // All issues were false positives - mark as LGTM
+                filteredFindings.push({
+                    ...finding,
+                    severity: 'LGTM',
+                    issues: []
+                });
+            }
+            else {
+                filteredFindings.push(finding);
+            }
+        }
+        logger_1.Logger.info(chalk_1.default.blue(`\n   📊 Self-Critique: ${removedCount} false positive(s) removed\n`));
+        return filteredFindings;
+    }
+    catch (error) {
+        logger_1.Logger.warn(chalk_1.default.yellow(`   ⚠️ Self-critique failed: ${error.message.slice(0, 100)}`));
+        logger_1.Logger.warn(chalk_1.default.yellow("   Keeping all issues as fallback."));
+        return findings;
+    }
+}

package/dist/scripts/core/debate.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debateIssue = debateIssue;
+const llamaindex_1 = require("llamaindex");
+const ai_1 = require("ai");
+const groq_1 = require("@ai-sdk/groq");
+const config_1 = require("../config");
+const chalk_1 = __importDefault(require("chalk"));
+const groq = (0, groq_1.createGroq)({ apiKey: process.env.GROQ_API_KEY });
+async function debateIssue(issueTitle, issueDescription, fileName, userArgument, index) {
+    // Validate API key before making any calls
+    if (!process.env.GROQ_API_KEY) {
+        throw new Error("GROQ_API_KEY is required for debate mode. Please set it in your .env.local file.");
+    }
+    console.log(chalk_1.default.dim("   🧠  Thinking... (Consulting the Brain)"));
+    // 1. Extract keywords/context
+    const query = `${userArgument} ${issueTitle}`;
+    // 2. Retrieve new context
+    const retriever = index.asRetriever({ similarityTopK: 2 });
+    const contextNodes = await retriever.retrieve(query);
+    const newContext = contextNodes.map(n => n.node.getContent(llamaindex_1.MetadataMode.NONE)).join("\n\n").slice(0, 2000);
+    if (newContext.length >= 2000) {
+        console.log(chalk_1.default.yellow("   ⚠️  Context truncated to 2000 chars"));
+    }
+    const sources = contextNodes.map(n => n.node.metadata?.['file_name']).filter(Boolean).join(', ');
+    if (sources) {
+        console.log(chalk_1.default.dim(`   🔍  Found relevant context from: ${sources}`));
+    }
+    // 3. Ask the Judge
+    const systemPrompt = `You are a Senior Code Reviewer in a debate with a developer.
+    
+    ORIGINAL FINDING: "${issueTitle} - ${issueDescription}" in file ${fileName}.
+    USER DEFENSE: "${userArgument}"
+    
+    NEW CONTEXT FOUND IN REPO:
+    ${newContext}
+    
+    TASK:
+    Analyze the USER INPUT.
+    
+    1. **IS IT A QUESTION?** (e.g., "What does this mean?", "Why is this wrong?")
+       - If yes, **EXPLAIN** the technical reasoning behind the finding. 
+       - Reference the specific code/context.
+       - Do NOT withdraw the issue (Severity: UNCHANGED).
+       - Tone: Educational and helpful.
+
+    2. **IS IT A DEFENSE/ARGUMENT?** (e.g., "This is handled in utils.ts", "It's a false positive because...")
+       - Evaluate if the user is correct based on the NEW CONTEXT.
+       - If user is RIGHT: Apologize and withdraw (Severity: LGTM).
+       - If user is WRONG: Explain why, citing the context. (Severity: UNCHANGED).
+    
+    RETURN JSON:
+    {
+      "response": "Conversational response (explanation or verdict).",
+      "severity": "P0_CRITICAL" | "P1_HIGH" | "P2_MEDIUM" | "LGTM" | "UNCHANGED"
+    }
+    `;
+    try {
+        const { text } = await (0, ai_1.generateText)({
+            model: groq(config_1.Config.MODEL_NAME),
+            system: systemPrompt,
+            prompt: "What is your verdict?",
+            temperature: 0.2,
+        });
+        const jsonMatch = text.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+            try {
+                const parsed = JSON.parse(jsonMatch[0]);
+                // Validate expected structure
+                if (parsed && typeof parsed.response === 'string' && parsed.severity) {
+                    return {
+                        text: parsed.response,
+                        severity: parsed.severity
+                    };
+                }
+            }
+            catch (parseError) {
+                // JSON parse failed, fall through to default response
+            }
+        }
+        return {
+            text: text,
+            severity: 'UNCHANGED'
+        };
+    }
+    catch (error) {
+        return {
+            text: `Failed to debate: ${error.message}`,
+            severity: 'UNCHANGED'
+        };
+    }
+}

package/dist/scripts/detective.js

@@ -40,6 +40,7 @@ exports.Detective = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
+const logger_1 = require("./utils/logger");
 const RULES = [
     {
         id: 'SEC-001',
@@ -125,19 +126,19 @@ class Detective {
     }
     report() {
         if (this.violations.length === 0) {
-            console.log(chalk_1.default.green("✅ Detective Engine: No violations found."));
+            logger_1.Logger.info(chalk_1.default.green("✅ Detective Engine: No violations found."));
             return;
         }
-        console.log(chalk_1.default.red(`🚨 Detective Engine found ${this.violations.length} violations:`));
+        logger_1.Logger.info(chalk_1.default.red(`🚨 Detective Engine found ${this.violations.length} violations:`));
         // Only show first 10 to avoid wall of text
         const total = this.violations.length;
         const toShow = this.violations.slice(0, 10);
         toShow.forEach(v => {
             const color = v.severity === 'high' ? chalk_1.default.red : chalk_1.default.yellow;
-            console.log(color(`[${v.code}] ${v.file}:${v.line} - ${v.message}`));
+            logger_1.Logger.info(color(`[${v.code}] ${v.file}:${v.line} - ${v.message}`));
         });
         if (total > 10) {
-            console.log(chalk_1.default.dim(`... and ${total - 10} more.`));
+            logger_1.Logger.dim(`... and ${total - 10} more.`);
         }
     }
 }