jstar-reviewer 2.1.4 → 2.2.0

package/scripts/ui/interaction.ts

@@ -0,0 +1,38 @@
+import prompts from 'prompts';
+import chalk from 'chalk';
+
+export type UserAction = 'accept' | 'discuss' | 'ignore' | 'exit';
+
+export async function showActionMenu(issueTitle: string): Promise<UserAction> {
+    try {
+        const response = await prompts({
+            type: 'select',
+            name: 'action',
+            message: `Action for: ${chalk.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';
+    }
+}
+
+export async function askForArgument(): Promise<string> {
+    try {
+        const response = await prompts({
+            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 '';
+    }
+}

package/scripts/utils/logger.ts

@@ -0,0 +1,118 @@
+import chalk from 'chalk';
+
+/**
+ * Logger Utility
+ * Centralizes all CLI output to support both human-readable (TTY) and machine-readable (JSON) modes.
+ * 
+ * Usage:
+ *   Logger.init(); // Auto-detects --json flag
+ *   Logger.info("Starting..."); // Suppressed in JSON mode
+ *   Logger.json({ status: "ok" }); // Only outputs in JSON mode
+ */
+
+let jsonMode = false;
+
+export const Logger = {
+    /**
+     * Initialize the logger.
+     * Auto-detects --json or --headless flags from process.argv.
+     */
+    init() {
+        jsonMode = process.argv.includes('--json') || process.argv.includes('--headless');
+    },
+
+    /**
+     * Check if we are in headless/JSON mode.
+     */
+    isHeadless() {
+        return jsonMode;
+    },
+
+    /**
+     * Alias for isHeadless for backwards compatibility.
+     */
+    isJsonMode() {
+        return jsonMode;
+    },
+
+    /**
+     * Standard informational message (suppressed in JSON mode).
+     */
+    info(message: string) {
+        if (!jsonMode) {
+            console.log(message);
+        }
+    },
+
+    /**
+     * Success message with green styling (suppressed in JSON mode).
+     */
+    success(message: string) {
+        if (!jsonMode) {
+            console.log(chalk.green(message));
+        }
+    },
+
+    /**
+     * Warning message with yellow styling (suppressed in JSON mode).
+     */
+    warn(message: string) {
+        if (!jsonMode) {
+            console.log(chalk.yellow(message));
+        }
+    },
+
+    /**
+     * Error message - always outputs to stderr.
+     */
+    error(message: string) {
+        console.error(chalk.red(message));
+    },
+
+    /**
+     * Dim/faded message for secondary info (suppressed in JSON mode).
+     */
+    dim(message: string) {
+        if (!jsonMode) {
+            console.log(chalk.dim(message));
+        }
+    },
+
+    /**
+     * Write inline (no newline) for progress indicators (suppressed in JSON mode).
+     * Alias: progress()
+     */
+    inline(message: string) {
+        if (!jsonMode) {
+            process.stdout.write(message);
+        }
+    },
+
+    /**
+     * Progress indicator - writes inline without newline.
+     */
+    progress(message: string) {
+        if (!jsonMode) {
+            process.stdout.write(message);
+        }
+    },
+
+    /**
+     * Output structured JSON to stdout.
+     * Only outputs in JSON mode. For API/AI consumption.
+     */
+    json(data: object) {
+        if (jsonMode) {
+            console.log(JSON.stringify(data, null, 2));
+        }
+    },
+
+    /**
+     * Output a single-line JSON object (for streaming events).
+     */
+    jsonLine(data: object) {
+        if (jsonMode) {
+            console.log(JSON.stringify(data));
+        }
+    }
+};

package/setup.js

@@ -115,7 +115,7 @@ async function main() {
 
     // HARDCODED: Tagged release URL - NOT configurable for security
     // To update, modify this constant and publish a new version of setup.js
-    const BASE_URL = 'https://raw.githubusercontent.com/JStaRFilms/jstar-code-review/v2.1.4';
+    const BASE_URL = 'https://raw.githubusercontent.com/JStaRFilms/jstar-code-review/v2.2.0';
 
     // Validate URL matches our exact expected pattern (defense in depth)
     function isValidUrl(url) {

package/scripts/local-embedding.ts

@@ -1,55 +0,0 @@
-import { pipeline, env } from "@xenova/transformers";
-
-// Skip local model checks if needed, or let it download
-env.allowLocalModels = false;
-env.useBrowserCache = false;
-
-export class LocalEmbedding {
-    private pipe: any;
-    private modelName: string;
-
-    constructor() {
-        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 pipeline("feature-extraction", this.modelName);
-        }
-    }
-
-    async getTextEmbedding(text: string): Promise<number[]> {
-        await this.init();
-        const result = await this.pipe(text, { pooling: "mean", normalize: true });
-        return Array.from(result.data);
-    }
-
-    async getQueryEmbedding(query: string): Promise<number[]> {
-        return this.getTextEmbedding(query);
-    }
-
-    // Batch method (Required by LlamaIndex)
-    async getTextEmbeddings(texts: string[]): Promise<number[][]> {
-        await this.init();
-        const embeddings: number[][] = [];
-        for (const text of texts) {
-            embeddings.push(await this.getTextEmbedding(text));
-        }
-        return embeddings;
-    }
-
-    // Stubs for BaseEmbedding interface compliance
-    embedBatchSize = 10;
-    similarity(embedding1: number[], embedding2: number[]): number {
-        // Simple dot product for normalized vectors
-        return embedding1.reduce((sum, val, i) => sum + val * embedding2[i], 0);
-    }
-    async transform(nodes: any[], _options?: any): Promise<any[]> {
-        for (const node of nodes) {
-            node.embedding = await this.getTextEmbedding(node.getContent("text"));
-        }
-        return nodes;
-    }
-    async getTextEmbeddingsBatch(texts: string[]): Promise<number[][]> { return this.getTextEmbeddings(texts); }
-}