jstar-reviewer 2.0.3 → 2.0.4

package/bin/jstar.js

@@ -70,27 +70,51 @@ function commandExists(cmd) {
 }
 
 function runScript(scriptName) {
+    // Look for transpiled files in dist/
+    // .ts becomes .js in dist
+    const jsName = scriptName.replace('.ts', '.js');
+    const distDir = path.join(__dirname, '..', 'dist', 'scripts');
+    const jsPath = path.join(distDir, jsName);
+
+    // Fallback for local development if dist doesn't exist
     const scriptsDir = path.join(__dirname, '..', 'scripts');
-    const scriptPath = path.join(scriptsDir, scriptName);
+    const tsPath = path.join(scriptsDir, scriptName);
+
+    const isWin = process.platform === 'win32';
 
-    if (!fs.existsSync(scriptPath)) {
+    if (fs.existsSync(jsPath)) {
+        log(`${COLORS.dim}Running ${jsName}...${COLORS.reset}`);
+        const child = spawn('node', [jsPath, ...process.argv.slice(3)], {
+            cwd: process.cwd(),
+            stdio: 'inherit',
+            shell: isWin,
+            env: {
+                ...process.env,
+                JSTAR_CWD: process.cwd()
+            }
+        });
+
+        child.on('close', (code) => process.exit(code || 0));
+        child.on('error', (err) => {
+            log(`${COLORS.red}Error running script: ${err.message}${COLORS.reset}`);
+            process.exit(1);
+        });
+        return;
+    }
+
+    if (!fs.existsSync(tsPath)) {
         log(`${COLORS.red}Error: Script not found: ${scriptPath}${COLORS.reset}`);
         process.exit(1);
     }
 
-    // Prioritize pnpm if available
+    // Fallback to ts-node if dist is not built (mostly for local development)
     const hasPnpm = commandExists('pnpm');
     const runner = hasPnpm ? 'pnpm' : 'npx';
     const runnerArgs = hasPnpm ? ['dlx', 'ts-node'] : ['ts-node'];
 
-    log(`${COLORS.dim}Using ${runner} to run ${scriptName}...${COLORS.reset}`);
-
-    // On Windows, global commands like pnpm/npx are .cmd files.
-    // spawn without shell: true often fails with EINVAL or ENOENT on Windows.
-    // We use shell: true only on Windows for reliability.
-    const isWin = process.platform === 'win32';
+    log(`${COLORS.dim}Using ${runner} (fallback) to run ${scriptName}...${COLORS.reset}`);
 
-    const child = spawn(runner, [...runnerArgs, scriptPath, ...process.argv.slice(3)], {
+    const child = spawn(runner, [...runnerArgs, tsPath, ...process.argv.slice(3)], {
         cwd: process.cwd(),
         stdio: 'inherit',
         shell: isWin,

package/dist/scripts/config.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = void 0;
+const dotenv_1 = __importDefault(require("dotenv"));
+// Load .env.local first, then .env
+dotenv_1.default.config({ path: ".env.local" });
+dotenv_1.default.config();
+/**
+ * Default fallback values.
+ * These are intentional fallbacks when environment variables are not configured.
+ * Override via REVIEW_MODEL_NAME env var for production use.
+ */
+const DEFAULT_MODEL = "moonshotai/kimi-k2-instruct-0905";
+exports.Config = {
+    MODEL_NAME: process.env.REVIEW_MODEL_NAME || DEFAULT_MODEL,
+    DEFAULT_SEVERITY: 'P2_MEDIUM',
+    THRESHOLDS: {
+        MEDIUM: 5
+    }
+};

package/dist/scripts/dashboard.js

@@ -0,0 +1,217 @@
+"use strict";
+/**
+ * J-Star Dashboard Renderer
+ * Generates professional markdown dashboard from review findings
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderDashboard = renderDashboard;
+exports.determineStatus = determineStatus;
+exports.generateRecommendation = generateRecommendation;
+const config_1 = require("./config");
+const SEVERITY_EMOJI = {
+    'P0_CRITICAL': '🛑',
+    'P1_HIGH': '⚠️',
+    'P2_MEDIUM': '📝',
+    'LGTM': '✅'
+};
+const SEVERITY_LABEL = {
+    'P0_CRITICAL': 'CRITICAL',
+    'P1_HIGH': 'HIGH',
+    'P2_MEDIUM': 'MEDIUM',
+    'LGTM': 'PASSED'
+};
+function getStatusEmoji(status) {
+    switch (status) {
+        case 'CRITICAL_FAILURE': return '🔴';
+        case 'NEEDS_REVIEW': return '🟡';
+        case 'APPROVED': return '🟢';
+    }
+}
+function formatDate() {
+    return new Date().toISOString().split('T')[0];
+}
+/**
+ * Renders a single issue row for the markdown table.
+ * Includes fallback handling for unexpected severity values to ensure
+ * the dashboard renders gracefully even if parsing produced invalid data.
+ */
+function renderIssueRow(file, issue, severity) {
+    // Fallback to '❓' and raw severity if the value is not in our known maps
+    const emoji = SEVERITY_EMOJI[severity] ?? '❓';
+    const label = SEVERITY_LABEL[severity] ?? severity;
+    return `| \`${file}\` | ${emoji} **${label}** | ${issue.title} |`;
+}
+function renderFixPrompt(issue) {
+    if (!issue.fixPrompt)
+        return '';
+    return `
+<details>
+<summary>🤖 <strong>Fix Prompt:</strong> ${issue.title}</summary>
+
+\`\`\`
+${issue.fixPrompt}
+\`\`\`
+
+</details>
+`;
+}
+/**
+ * Validates that the report object has the required structure.
+ * This guards against runtime errors from malformed LLM responses or corrupted data.
+ */
+function validateReport(report) {
+    if (!report || typeof report !== 'object')
+        return false;
+    const r = report;
+    // Check required fields exist
+    if (typeof r.status !== 'string')
+        return false;
+    if (typeof r.recommendedAction !== 'string')
+        return false;
+    if (!Array.isArray(r.findings))
+        return false;
+    if (!r.metrics || typeof r.metrics !== 'object')
+        return false;
+    // Validate metrics structure
+    const m = r.metrics;
+    const requiredMetrics = ['filesScanned', 'totalTokens', 'violations', 'critical', 'high', 'medium', 'lgtm'];
+    for (const key of requiredMetrics) {
+        if (typeof m[key] !== 'number')
+            return false;
+    }
+    return true;
+}
+function renderDashboard(report) {
+    // Runtime validation to catch malformed reports early
+    if (!validateReport(report)) {
+        throw new Error('Invalid DashboardReport: missing or malformed required fields');
+    }
+    const { metrics, findings, status, recommendedAction } = report;
+    // Group findings by severity
+    const critical = findings.filter(f => f.severity === 'P0_CRITICAL');
+    const high = findings.filter(f => f.severity === 'P1_HIGH');
+    const medium = findings.filter(f => f.severity === 'P2_MEDIUM');
+    const lgtm = findings.filter(f => f.severity === 'LGTM');
+    let md = `# 📊 J-STAR CODE REVIEW DASHBOARD
+
+**Date:** \`${formatDate()}\` | **Reviewer:** \`Detective Engine & Judge\` | **Status:** ${getStatusEmoji(status)} **${status.replace('_', ' ')}**
+
+---
+
+## 1. 📈 EXECUTIVE SUMMARY
+
+| Metric | Value | Status |
+| --- | --- | --- |
+| **Files Scanned** | **${metrics.filesScanned}** | 🔎 Complete |
+| **Total Tokens** | **~${metrics.totalTokens.toLocaleString()}** | ⚖️ Processed |
+| **Total Violations** | **${metrics.violations}** | ${metrics.violations > 0 ? '🚨 Action Required' : '✅ Clean'} |
+| **Critical (P0)** | **${metrics.critical}** | ${metrics.critical > 0 ? '🛑 **BLOCKER**' : '✅ None'} |
+| **High (P1)** | **${metrics.high}** | ${metrics.high > 0 ? '⚠️ Needs Fix' : '✅ None'} |
+| **Medium (P2)** | **${metrics.medium}** | ${metrics.medium > 0 ? '📝 Review' : '✅ None'} |
+| **Passed (LGTM)** | **${metrics.lgtm}** | ✅ Clean |
+
+---
+
+`;
+    // Critical Section
+    if (critical.length > 0) {
+        md += `## 2. 🛑 CRITICAL SECURITY VULNERABILITIES (P0)
+
+> **These files contain blockers that must be fixed before any merge.**
+
+| File | Severity | Issue |
+| --- | --- | --- |
+`;
+        for (const finding of critical) {
+            for (const issue of finding.issues) {
+                md += renderIssueRow(finding.file, issue, 'P0_CRITICAL') + '\n';
+            }
+        }
+        md += '\n### 🤖 Fix Prompts (P0)\n\n';
+        for (const finding of critical) {
+            for (const issue of finding.issues) {
+                md += renderFixPrompt(issue);
+            }
+        }
+        md += '\n---\n\n';
+    }
+    // High Section
+    if (high.length > 0) {
+        md += `## 3. ⚠️ HIGH PRIORITY ISSUES (P1)
+
+> **Architecture and logic issues requiring significant attention.**
+
+| File | Severity | Issue |
+| --- | --- | --- |
+`;
+        for (const finding of high) {
+            for (const issue of finding.issues) {
+                md += renderIssueRow(finding.file, issue, 'P1_HIGH') + '\n';
+            }
+        }
+        md += '\n### 🤖 Fix Prompts (P1)\n\n';
+        for (const finding of high) {
+            for (const issue of finding.issues) {
+                md += renderFixPrompt(issue);
+            }
+        }
+        md += '\n---\n\n';
+    }
+    // Medium Section
+    if (medium.length > 0) {
+        md += `## 4. 📝 MEDIUM PRIORITY ISSUES (P2)
+
+> **Code quality and maintenance items.**
+
+| File | Severity | Issue |
+| --- | --- | --- |
+`;
+        for (const finding of medium) {
+            for (const issue of finding.issues) {
+                md += renderIssueRow(finding.file, issue, 'P2_MEDIUM') + '\n';
+            }
+        }
+        md += '\n---\n\n';
+    }
+    // LGTM Section
+    if (lgtm.length > 0) {
+        md += `## 5. ✅ PASSED REVIEW (LGTM)
+
+> **No issues found in these files.**
+
+`;
+        for (const finding of lgtm) {
+            md += `- \`${finding.file}\`\n`;
+        }
+        md += '\n---\n\n';
+    }
+    // Recommended Action
+    md += `## 🎯 RECOMMENDED ACTION
+
+> ${recommendedAction}
+
+---
+
+*Generated by J-Star Code Reviewer v2*
+`;
+    return md;
+}
+function determineStatus(metrics) {
+    if (metrics.critical > 0)
+        return 'CRITICAL_FAILURE';
+    if (metrics.high > 0 || metrics.medium > config_1.Config.THRESHOLDS.MEDIUM)
+        return 'NEEDS_REVIEW';
+    return 'APPROVED';
+}
+function generateRecommendation(metrics) {
+    if (metrics.critical > 0) {
+        return `**BLOCK MERGE:** Fix ${metrics.critical} critical issue(s) immediately. Review P0 fix prompts above.`;
+    }
+    if (metrics.high > 0) {
+        return `**Request Changes:** Address ${metrics.high} high-priority issue(s) before merging.`;
+    }
+    if (metrics.medium > 0) {
+        return `**Approve with Notes:** ${metrics.medium} medium issues found. Consider fixing in follow-up PR.`;
+    }
+    return `**Approve:** All files passed review. Ship it! 🚀`;
+}

package/dist/scripts/detective.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 });
+exports.Detective = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const RULES = [
+    {
+        id: 'SEC-001',
+        severity: 'high',
+        message: 'Possible Hardcoded Secret detected',
+        pattern: /(api_key|secret|password|token)\s*[:=]\s*['"`][a-zA-Z0-9_\-\.]{10,}['"`]/i
+    },
+    {
+        id: 'ARCH-001',
+        severity: 'medium',
+        message: 'Avoid using console.log in production code',
+        pattern: /console\.log\(/
+    },
+];
+// File-level rules that check the whole content
+const FILE_RULES = [
+    {
+        id: 'ARCH-002',
+        severity: 'high',
+        message: 'Next.js "use client" must be at the very top of the file',
+        pattern: /^(?!['"]use client['"]).*['"]use client['"]/s,
+        filePattern: /\.tsx?$/
+    }
+];
+class Detective {
+    constructor(directory) {
+        this.directory = directory;
+        this.violations = [];
+    }
+    async scan() {
+        this.walk(this.directory);
+        return this.violations;
+    }
+    walk(dir) {
+        if (!fs.existsSync(dir))
+            return;
+        const files = fs.readdirSync(dir);
+        for (const file of files) {
+            const filePath = path.join(dir, file);
+            const stat = fs.statSync(filePath);
+            if (stat.isDirectory()) {
+                if (file !== 'node_modules' && file !== '.git' && file !== '.jstar') {
+                    this.walk(filePath);
+                }
+            }
+            else {
+                this.checkFile(filePath);
+            }
+        }
+    }
+    checkFile(filePath) {
+        if (!filePath.match(/\.(ts|tsx|js|jsx)$/))
+            return;
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n');
+        // Line-based rules
+        for (const rule of RULES) {
+            if (rule.filePattern && !filePath.match(rule.filePattern))
+                continue;
+            lines.forEach((line, index) => {
+                if (rule.pattern.test(line)) {
+                    this.addViolation(filePath, index + 1, rule);
+                }
+            });
+        }
+        // File-based rules
+        for (const rule of FILE_RULES) {
+            if (rule.filePattern && !filePath.match(rule.filePattern))
+                continue;
+            if (rule.pattern.test(content)) {
+                this.addViolation(filePath, 1, rule);
+            }
+        }
+    }
+    addViolation(filePath, line, rule) {
+        this.violations.push({
+            file: path.relative(process.cwd(), filePath),
+            line,
+            message: rule.message,
+            severity: rule.severity,
+            code: rule.id
+        });
+    }
+    report() {
+        if (this.violations.length === 0) {
+            console.log(chalk_1.default.green("✅ Detective Engine: No violations found."));
+            return;
+        }
+        console.log(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}`));
+        });
+        if (total > 10) {
+            console.log(chalk_1.default.dim(`... and ${total - 10} more.`));
+        }
+    }
+}
+exports.Detective = Detective;
+// CLI Integration
+if (require.main === module) {
+    const detective = new Detective(path.join(process.cwd(), 'src'));
+    detective.scan();
+    detective.report();
+}

package/dist/scripts/gemini-embedding.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiEmbedding = void 0;
+const generative_ai_1 = require("@google/generative-ai");
+class GeminiEmbedding {
+    constructor() {
+        // Stubs for BaseEmbedding compliance
+        this.embedBatchSize = 10;
+        const apiKey = process.env.GOOGLE_API_KEY;
+        if (!apiKey) {
+            throw new Error("GOOGLE_API_KEY is missing from environment variables.");
+        }
+        this.genAI = new generative_ai_1.GoogleGenerativeAI(apiKey);
+        // User requested 'text-embedding-004', which has better rate limits
+        this.model = this.genAI.getGenerativeModel({ model: "text-embedding-004" });
+    }
+    async getTextEmbedding(text) {
+        // Retry logic for transient network errors
+        let retries = 0;
+        const maxRetries = 3;
+        while (retries < maxRetries) {
+            try {
+                const result = await this.model.embedContent(text);
+                return result.embedding.values;
+            }
+            catch (e) {
+                if (e.message.includes("fetch failed") || e.message.includes("network")) {
+                    retries++;
+                    const waitTime = Math.pow(2, retries) * 1000;
+                    console.warn(`⚠️ Network error. Retrying in ${waitTime / 1000}s... (${retries}/${maxRetries})`);
+                    await new Promise(resolve => setTimeout(resolve, waitTime));
+                }
+                else {
+                    throw e;
+                }
+            }
+        }
+        throw new Error("Max retries exceeded for embedding request.");
+    }
+    async getQueryEmbedding(query) {
+        return this.getTextEmbedding(query);
+    }
+    async getTextEmbeddings(texts) {
+        const embeddings = [];
+        console.log(`Creating embeddings for ${texts.length} chunks (Batching to avoid rate limits)...`);
+        // Process in smaller batches with delay
+        const BATCH_SIZE = 1; // Strict serial for safety on free tier
+        const DELAY_MS = 1000; // 1s delay between calls
+        for (let i = 0; i < texts.length; i += BATCH_SIZE) {
+            const batch = texts.slice(i, i + BATCH_SIZE);
+            for (const text of batch) {
+                let retries = 0;
+                let success = false;
+                while (!success && retries < 5) {
+                    try {
+                        const embedding = await this.getTextEmbedding(text);
+                        embeddings.push(embedding);
+                        success = true;
+                        // Standard delay between calls
+                        await new Promise(resolve => setTimeout(resolve, DELAY_MS));
+                        process.stdout.write("."); // Progress indicator
+                    }
+                    catch (e) {
+                        if (e.message.includes("429") || e.message.includes("quota")) {
+                            retries++;
+                            const waitTime = Math.pow(2, retries) * 2000; // 2s, 4s, 8s, 16s...
+                            console.warn(`\n⚠️  Rate limit hit. Retrying in ${waitTime / 1000}s...`);
+                            await new Promise(resolve => setTimeout(resolve, waitTime));
+                        }
+                        else {
+                            console.error("\n❌ Embedding failed irreversibly:", e.message);
+                            throw e;
+                        }
+                    }
+                }
+                if (!success) {
+                    throw new Error("Max retries exceeded for rate limits.");
+                }
+            }
+        }
+        console.log("\n✅ Done embedding.");
+        return embeddings;
+    }
+    similarity(embedding1, embedding2) {
+        return embedding1.reduce((sum, val, i) => sum + val * embedding2[i], 0);
+    }
+    async transform(nodes, _options) {
+        for (const node of nodes) {
+            node.embedding = await this.getTextEmbedding(node.getContent("text"));
+        }
+        return nodes;
+    }
+    async getTextEmbeddingsBatch(texts) { return this.getTextEmbeddings(texts); }
+}
+exports.GeminiEmbedding = GeminiEmbedding;

package/dist/scripts/indexer.js

@@ -0,0 +1,126 @@
+"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 llamaindex_1 = require("llamaindex");
+const gemini_embedding_1 = require("./gemini-embedding");
+const mock_llm_1 = require("./mock-llm");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const chalk_1 = __importDefault(require("chalk"));
+const dotenv_1 = __importDefault(require("dotenv"));
+// Load .env.local first, then .env
+dotenv_1.default.config({ path: ".env.local" });
+dotenv_1.default.config();
+// Configuration
+const STORAGE_DIR = path.join(process.cwd(), ".jstar", "storage");
+const SOURCE_DIR = path.join(process.cwd(), "scripts"); // Changed from src/ to scripts/
+// Ensure OpenAI Key exists (LlamaIndex default) or fallback if we configured something else
+// (We are using local now, so this check is less critical, but good to have if we revert)
+// if (!process.env.OPENAI_API_KEY) {
+//     console.warn(chalk.yellow("⚠️  OPENAI_API_KEY not found. Embeddings may fail unless you have configured a local model."));
+// }
+async function main() {
+    const args = process.argv.slice(2);
+    const isWatch = args.includes("--watch");
+    console.log(chalk_1.default.blue("🧠 J-Star Indexer: Scanning codebase..."));
+    // 1. Load documents (Your Code)
+    if (!fs.existsSync(SOURCE_DIR)) {
+        console.error(chalk_1.default.red(`❌ Source directory not found: ${SOURCE_DIR}`));
+        process.exit(1);
+    }
+    const reader = new llamaindex_1.SimpleDirectoryReader();
+    const documents = await reader.loadData({ directoryPath: SOURCE_DIR });
+    console.log(chalk_1.default.yellow(`📄 Found ${documents.length} files to index.`));
+    const isInit = args.includes("--init");
+    try {
+        // 2. Setup Service Context with Google Gemini Embeddings
+        // using 'models/text-embedding-004' which is a strong, recent model
+        const embedModel = new gemini_embedding_1.GeminiEmbedding();
+        const llm = new mock_llm_1.MockLLM();
+        const serviceContext = (0, llamaindex_1.serviceContextFromDefaults)({
+            embedModel,
+            llm: llm
+        });
+        // 3. Create the Storage Context
+        let storageContext;
+        if (isInit) {
+            console.log(chalk_1.default.blue("✨ Initializing fresh Local Brain..."));
+            storageContext = await (0, llamaindex_1.storageContextFromDefaults)({});
+        }
+        else {
+            // Try to load
+            if (!fs.existsSync(STORAGE_DIR)) {
+                console.log(chalk_1.default.yellow("⚠️  Storage not found. Running fresh init..."));
+                storageContext = await (0, llamaindex_1.storageContextFromDefaults)({});
+            }
+            else {
+                storageContext = await (0, llamaindex_1.storageContextFromDefaults)({
+                    persistDir: STORAGE_DIR,
+                });
+            }
+        }
+        // 4. Generate the Index
+        const index = await llamaindex_1.VectorStoreIndex.fromDocuments(documents, {
+            storageContext,
+            serviceContext,
+        });
+        // 4. Persist (Save the Brain)
+        // Manual persistence for LlamaIndex TS compatibility
+        const ctxToPersist = index.storageContext;
+        if (ctxToPersist.docStore)
+            await ctxToPersist.docStore.persist(path.join(STORAGE_DIR, "doc_store.json"));
+        if (ctxToPersist.vectorStore)
+            await ctxToPersist.vectorStore.persist(path.join(STORAGE_DIR, "vector_store.json"));
+        if (ctxToPersist.indexStore)
+            await ctxToPersist.indexStore.persist(path.join(STORAGE_DIR, "index_store.json"));
+        if (ctxToPersist.propStore)
+            await ctxToPersist.propStore.persist(path.join(STORAGE_DIR, "property_store.json"));
+        console.log(chalk_1.default.green("✅ Indexing Complete. Brain is updated."));
+        if (isWatch) {
+            console.log(chalk_1.default.blue("👀 Watch mode enabled."));
+        }
+    }
+    catch (e) {
+        console.error(chalk_1.default.red("❌ Indexing Failed:"), e.message);
+        if (e.message.includes("OpenAI")) {
+            console.log(chalk_1.default.yellow("👉 Tip: Make sure you have OPENAI_API_KEY in your .env file (or configure a local embedding model)."));
+        }
+        process.exit(1);
+    }
+}
+main().catch(console.error);

package/dist/scripts/local-embedding.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalEmbedding = void 0;
+const transformers_1 = require("@xenova/transformers");
+// Skip local model checks if needed, or let it download
+transformers_1.env.allowLocalModels = false;
+transformers_1.env.useBrowserCache = false;
+class LocalEmbedding {
+    constructor() {
+        // Stubs for BaseEmbedding interface compliance
+        this.embedBatchSize = 10;
+        this.modelName = "Xenova/bge-small-en-v1.5";
+    }
+    async init() {
+        if (!this.pipe) {
+            console.log("📥 Loading local embedding model (Xenova/bge-small-en-v1.5)...");
+            this.pipe = await (0, transformers_1.pipeline)("feature-extraction", this.modelName);
+        }
+    }
+    async getTextEmbedding(text) {
+        await this.init();
+        const result = await this.pipe(text, { pooling: "mean", normalize: true });
+        return Array.from(result.data);
+    }
+    async getQueryEmbedding(query) {
+        return this.getTextEmbedding(query);
+    }
+    // Batch method (Required by LlamaIndex)
+    async getTextEmbeddings(texts) {
+        await this.init();
+        const embeddings = [];
+        for (const text of texts) {
+            embeddings.push(await this.getTextEmbedding(text));
+        }
+        return embeddings;
+    }
+    similarity(embedding1, embedding2) {
+        // Simple dot product for normalized vectors
+        return embedding1.reduce((sum, val, i) => sum + val * embedding2[i], 0);
+    }
+    async transform(nodes, _options) {
+        for (const node of nodes) {
+            node.embedding = await this.getTextEmbedding(node.getContent("text"));
+        }
+        return nodes;
+    }
+    async getTextEmbeddingsBatch(texts) { return this.getTextEmbeddings(texts); }
+}
+exports.LocalEmbedding = LocalEmbedding;

package/dist/scripts/mock-llm.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockLLM = void 0;
+class MockLLM {
+    constructor() {
+        this.hasStreaming = false;
+        this.metadata = {
+            model: "mock",
+            temperature: 0,
+            topP: 1,
+            contextWindow: 1024,
+            tokenizer: undefined,
+        };
+    }
+    async chat(messages, parentEvent) {
+        return { message: { content: "Mock response" } };
+    }
+    async complete(prompt, parentEvent) {
+        return { text: "Mock response" };
+    }
+}
+exports.MockLLM = MockLLM;

package/dist/scripts/reviewer.js

@@ -0,0 +1,287 @@
+"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 ai_1 = require("ai");
+const groq_1 = require("@ai-sdk/groq");
+const google_1 = require("@ai-sdk/google");
+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 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 llamaindex_1 = require("llamaindex");
+const google = (0, google_1.createGoogleGenerativeAI)({ apiKey: process.env.GOOGLE_API_KEY });
+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();
+const serviceContext = (0, llamaindex_1.serviceContextFromDefaults)({ embedModel, llm: llm });
+const STORAGE_DIR = path.join(process.cwd(), ".jstar", "storage");
+const SOURCE_DIR = path.join(process.cwd(), "scripts");
+const OUTPUT_FILE = path.join(process.cwd(), ".jstar", "last-review.md");
+const git = (0, simple_git_1.default)();
+// --- Config ---
+const MODEL_NAME = config_1.Config.MODEL_NAME;
+const MAX_TOKENS_PER_REQUEST = 8000;
+const CHARS_PER_TOKEN = 4;
+const DELAY_BETWEEN_CHUNKS_MS = 2000;
+// --- Helpers ---
+function estimateTokens(text) {
+    return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+const EXCLUDED_PATTERNS = [
+    /pnpm-lock\.yaml/,
+    /package-lock\.json/,
+    /yarn\.lock/,
+    /\.env/,
+    /\.json$/,
+    /\.txt$/,
+    /\.md$/,
+    /node_modules/,
+    /\.jstar\//,
+];
+function shouldSkipFile(fileName) {
+    return EXCLUDED_PATTERNS.some(pattern => pattern.test(fileName));
+}
+function chunkDiffByFile(diff) {
+    return diff.split(/(?=^diff --git)/gm).filter(Boolean);
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function parseReviewResponse(text) {
+    try {
+        // Try to extract JSON from the response
+        const jsonMatch = text.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+            const parsed = JSON.parse(jsonMatch[0]);
+            // Validate structure
+            if (parsed &&
+                typeof parsed === 'object' &&
+                Array.isArray(parsed.issues) &&
+                ['P0_CRITICAL', 'P1_HIGH', 'P2_MEDIUM', 'LGTM'].includes(parsed.severity)) {
+                return {
+                    severity: parsed.severity,
+                    issues: parsed.issues
+                };
+            }
+        }
+    }
+    catch (e) {
+        // Parse failed, try to extract from markdown
+    }
+    // Fallback: If "LGTM" in text, it's clean
+    if (text.includes('LGTM') || text.includes('✅')) {
+        return { severity: 'LGTM', issues: [] };
+    }
+    // Otherwise, assume there are issues (treat as medium)
+    return {
+        severity: config_1.Config.DEFAULT_SEVERITY,
+        issues: [{
+                title: 'Review Notes',
+                description: text.slice(0, 500),
+                fixPrompt: 'Review the file and address the issues mentioned above.'
+            }]
+    };
+}
+// --- Main ---
+async function main() {
+    console.log(chalk_1.default.blue("🕵️  J-Star Reviewer: Analyzing your changes...\n"));
+    // 0. Detective
+    console.log(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'?)"));
+        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."));
+        return;
+    }
+    const storageContext = await (0, llamaindex_1.storageContextFromDefaults)({ persistDir: STORAGE_DIR });
+    const index = await llamaindex_1.VectorStoreIndex.init({ storageContext, serviceContext });
+    // 3. Retrieval
+    const retriever = index.asRetriever({ similarityTopK: 1 });
+    const keywords = (diff.match(/import .* from ['"](.*)['"]/g) || [])
+        .map(s => s.replace(/import .* from ['"](.*)['"]/, '$1'))
+        .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.`));
+    // 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.
+
+Analyze the Git Diff and return a JSON response with this EXACT structure:
+{
+  "severity": "P0_CRITICAL" | "P1_HIGH" | "P2_MEDIUM" | "LGTM",
+  "issues": [
+    {
+      "title": "Short issue title",
+      "description": "Detailed description of the problem",
+      "line": 42,
+      "fixPrompt": "A specific prompt an AI can use to fix this issue"
+    }
+  ]
+}
+
+SEVERITY GUIDE:
+- P0_CRITICAL: Security vulnerabilities, data leaks, auth bypass, SQL injection
+- P1_HIGH: Missing validation, race conditions, architectural violations
+- 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": []}
+
+Context: ${relatedContext.slice(0, 800)}`;
+    const findings = [];
+    let chunkIndex = 0;
+    let skippedCount = 0;
+    console.log(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)`));
+            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)`));
+            findings.push({
+                file: fileName,
+                severity: config_1.Config.DEFAULT_SEVERITY,
+                issues: [{
+                        title: 'File too large for review',
+                        description: `This file has ~${chunkTokens} tokens which exceeds the limit.`,
+                        fixPrompt: 'Consider splitting this file into smaller modules.'
+                    }]
+            });
+            continue;
+        }
+        process.stdout.write(chalk_1.default.dim(`   📄 ${fileName}...`));
+        try {
+            const { text } = await (0, ai_1.generateText)({
+                model: groq(MODEL_NAME),
+                system: systemPrompt,
+                prompt: `REVIEW THIS DIFF:\n\n${chunk}`,
+                temperature: 0.1,
+            });
+            const response = parseReviewResponse(text);
+            findings.push({
+                file: fileName,
+                severity: response.severity,
+                issues: response.issues
+            });
+            const emoji = response.severity === 'LGTM' ? '✅' :
+                response.severity === 'P0_CRITICAL' ? '🛑' :
+                    response.severity === 'P1_HIGH' ? '⚠️' : '📝';
+            console.log(` ${emoji}`);
+        }
+        catch (error) {
+            console.log(chalk_1.default.red(` ❌ (${error.message.slice(0, 50)})`));
+            findings.push({
+                file: fileName,
+                severity: config_1.Config.DEFAULT_SEVERITY,
+                issues: [{
+                        title: 'Review failed',
+                        description: error.message,
+                        fixPrompt: 'Retry the review or check manually.'
+                    }]
+            });
+        }
+        // Rate limit delay
+        if (chunkIndex < fileChunks.length) {
+            await sleep(DELAY_BETWEEN_CHUNKS_MS);
+        }
+    }
+    // 6. 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,
+    };
+    const report = {
+        date: new Date().toISOString().split('T')[0],
+        reviewer: 'Detective Engine & Judge',
+        status: (0, dashboard_1.determineStatus)(metrics),
+        metrics,
+        findings,
+        recommendedAction: (0, dashboard_1.generateRecommendation)(metrics)
+    };
+    // 7. Render and Save Dashboard
+    const dashboard = (0, dashboard_1.renderDashboard)(report);
+    // 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)));
+    // 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}`));
+}
+main().catch(console.error);

package/dist/scripts/types.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * J-Star Reviewer Types
+ * Structured types for dashboard output
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMPTY_REVIEW = void 0;
+/**
+ * Default empty response for parse failures
+ */
+exports.EMPTY_REVIEW = {
+    severity: 'LGTM',
+    issues: []
+};

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "jstar-reviewer",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "description": "Local-First, Context-Aware AI Code Reviewer - Works with any language",
   "bin": {
     "jstar": "bin/jstar.js"
   },
   "scripts": {
+    "build": "tsc",
     "index:init": "ts-node scripts/indexer.ts --init",
     "index:watch": "ts-node scripts/indexer.ts --watch",
     "review": "ts-node scripts/reviewer.ts",
@@ -50,6 +51,7 @@
   "files": [
     "bin/",
     "scripts/",
+    "dist/",
     "README.md"
   ],
   "main": "setup.js",