jstar-reviewer 2.0.3 → 2.1.0

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,123 @@
+"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"));
+// Configuration
+const STORAGE_DIR = path.join(process.cwd(), ".jstar", "storage");
+const SOURCE_DIR = path.join(process.cwd(), "scripts"); // Changed from src/ to scripts/
+async function main() {
+    // 0. Environment Validation
+    if (!process.env.GOOGLE_API_KEY) {
+        console.error(chalk_1.default.red("❌ Missing GOOGLE_API_KEY!"));
+        console.log(chalk_1.default.yellow("\nPlease ensure you have a .env.local file. Check .env.example for a template.\n"));
+        process.exit(1);
+    }
+    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,296 @@
+"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. 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"));
+        return;
+    }
+    // 1. 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,17 +1,10 @@
 {
   "name": "jstar-reviewer",
-  "version": "2.0.3",
+  "version": "2.1.0",
   "description": "Local-First, Context-Aware AI Code Reviewer - Works with any language",
   "bin": {
     "jstar": "bin/jstar.js"
   },
-  "scripts": {
-    "index:init": "ts-node scripts/indexer.ts --init",
-    "index:watch": "ts-node scripts/indexer.ts --watch",
-    "review": "ts-node scripts/reviewer.ts",
-    "detect": "ts-node scripts/detective.ts",
-    "prepare": "husky install"
-  },
   "keywords": [
     "code-review",
     "ai",
@@ -50,6 +43,7 @@
   "files": [
     "bin/",
     "scripts/",
+    "dist/",
     "README.md"
   ],
   "main": "setup.js",
@@ -60,5 +54,12 @@
   "type": "commonjs",
   "bugs": {
     "url": "https://github.com/JStaRFilms/jstar-code-review/issues"
+  },
+  "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",
+    "detect": "ts-node scripts/detective.ts"
   }
 }