scai 0.1.49 → 0.1.51

package/README.md

@@ -1,16 +1,15 @@
-# ⚙️ scai — Smart Commit AI ✨
+# ⚙️ scai — Smart Commit & Review AI ✨
 
+> AI-powered CLI tool for commit messages **and** pull request reviews — using local models.
 
-> AI-powered CLI tool for commits and summaries — using local models.
+**scai** is your AI pair‑programmer in the terminal. Focus on coding while scai:
 
-
-**scai** is a privacy-first, local AI assistant for developers. It brings semantic understanding to your codebase, directly from the terminal:
-
-- 💬 Suggest intelligent Git commit messages  
-- 🧐 Summarize files in plain English  
-- 📜 Auto-update your changelog  
-- 🔍 Search and ask questions across your codebase (ALPHA)  
-- 🔐 100% local — no API keys, no cloud, no telemetry
+- 🤖 **Reviews open pull requests** and provides AI‑driven feedback (BETA)  
+- 💬 **Suggests intelligent Git commit messages** based on your staged diff  
+- 📝 Summarizes files in plain English  
+- 📜 Auto‑updates your changelog  
+- 🔍 (ALPHA) Search & ask questions across your codebase  
+- 🔐 100% local — no API keys, no cloud, no telemetry  
 
 ---
 

package/dist/commands/AskCmd.js

@@ -5,12 +5,12 @@ import { searchFiles, queryFiles, getFunctionsForFiles } from '../db/fileIndex.j
 import { sanitizeQueryForFts } from '../utils/sanitizeQuery.js';
 import { generate } from '../lib/generate.js';
 import { buildContextualPrompt } from '../utils/buildContextualPrompt.js';
-import { generateFileTree } from '../utils/fileTree.js';
+import { generateFocusedFileTree } from '../utils/fileTree.js';
 import { log } from '../utils/log.js';
 import { PROMPT_LOG_PATH, SCAI_HOME, INDEX_DIR, RELATED_FILES_LIMIT, MAX_SUMMARY_LINES } from '../constants.js';
 export async function runAskCommand(query) {
     if (!query) {
-        query = await promptOnce('🧠 Ask your question:\n> ');
+        query = await promptOnce('💬 Ask your question:\n');
     }
     query = query.trim();
     if (!query) {
@@ -103,7 +103,7 @@ export async function runAskCommand(query) {
     // 🟩 STEP 6: Generate file tree
     let fileTree = '';
     try {
-        fileTree = generateFileTree(INDEX_DIR, 2);
+        fileTree = generateFocusedFileTree(INDEX_DIR, filepath, 2);
     }
     catch (e) {
         console.warn('⚠️ Could not generate file tree:', e);
@@ -144,11 +144,12 @@ export async function runAskCommand(query) {
 // 🟩 Helper: Prompt once
 function promptOnce(promptText) {
     return new Promise(resolve => {
+        console.log(promptText); // Instead of putting it *in* rl.question
         const rl = readline.createInterface({
             input: process.stdin,
             output: process.stdout,
         });
-        rl.question(promptText, answer => {
+        rl.question('> ', answer => {
             rl.close();
             resolve(answer.trim());
         });

package/dist/commands/FindCmd.js

@@ -1,6 +1,7 @@
 import { queryFiles } from '../db/fileIndex.js';
 import { sanitizeQueryForFts } from '../utils/sanitizeQuery.js';
 import path from 'path';
+import os from 'os';
 export async function runFindCommand(query) {
     if (!query) {
         console.error('❌ Please provide a search query.\n👉 Usage: scai find "keyword"');
@@ -13,9 +14,15 @@ export async function runFindCommand(query) {
         console.log('⚠️ No matching files found.');
         return;
     }
-    console.log(`✅ Found ${results.length} result(s).`);
-    console.log();
+    console.log(`✅ Found ${results.length} result(s).\n`);
+    const homeDir = os.homedir();
     results.forEach((result, index) => {
-        console.log(`📄 [${index + 1}] ${path.relative(process.cwd(), result.path)}`);
+        let absPath = path.resolve(result.path); // ensure absolute path
+        if (absPath.startsWith(homeDir)) {
+            absPath = absPath.replace(homeDir, '~');
+        }
+        // Normalize to forward slashes (especially for Windows)
+        absPath = absPath.replace(/\\/g, '/');
+        console.log(`📄 [${index + 1}] ${absPath}`);
     });
 }

package/dist/commands/ReviewCmd.js

@@ -0,0 +1,178 @@
+import readline from 'readline';
+import { reviewModule } from '../pipeline/modules/reviewModule.js';
+import { fetchOpenPullRequests, fetchPullRequestDiff, getGitHubUsername, submitReview } from '../github/github.js';
+import { getRepoDetails } from '../github/repo.js';
+import { ensureGitHubAuth } from '../github/auth.js';
+// Function to fetch the PRs with requested reviews for a specific branch (default to 'main')
+export async function getPullRequestsForReview(token, owner, repo, username, branch = 'main', filterForUser = true) {
+    const prs = await fetchOpenPullRequests(token, owner, repo);
+    const filtered = [];
+    const failedPRs = [];
+    for (const pr of prs) {
+        const isDraft = pr.draft;
+        const isMerged = pr.merged_at != null;
+        const shouldInclude = !isDraft &&
+            !isMerged &&
+            (!filterForUser || pr.requested_reviewers?.some(r => r.login === username));
+        if (shouldInclude) {
+            const diffUrl = `https://api.github.com/repos/${owner}/${repo}/pulls/${pr.number}.diff`;
+            try {
+                const diffRes = await fetch(diffUrl, {
+                    headers: {
+                        Authorization: `token ${token}`,
+                        Accept: 'application/vnd.github.v3.diff',
+                    },
+                });
+                if (!diffRes.ok) {
+                    throw new Error(`${diffRes.status} ${diffRes.statusText}`);
+                }
+                const diff = await diffRes.text();
+                filtered.push({ pr, diff });
+            }
+            catch (err) {
+                console.warn(`⚠️ Could not fetch diff for PR #${pr.number}: ${err.message}`);
+                failedPRs.push(pr);
+            }
+        }
+    }
+    if (failedPRs.length > 0) {
+        console.warn(`\n⚠️ Skipped ${failedPRs.length} PR(s) due to diff fetch failures:`);
+        for (const pr of failedPRs) {
+            console.warn(`  - #${pr.number}: ${pr.title}`);
+        }
+        console.warn('These PRs will not be included in the review summary.\n');
+    }
+    return filtered;
+}
+// Ask user to pick a PR to review
+function askUserToPickPR(prs) {
+    return new Promise((resolve) => {
+        if (prs.length === 0) {
+            console.log("⚠️ No pull requests with review requested.");
+            return resolve(null);
+        }
+        console.log("\n📦 Open Pull Requests with review requested:");
+        prs.forEach((pr, i) => {
+            console.log(`${i + 1}) #${pr.number} - ${pr.title}`);
+        });
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question(`\n👉 Choose a PR to review [1-${prs.length}]: `, (answer) => {
+            rl.close();
+            const index = parseInt(answer, 10);
+            if (!isNaN(index) && index >= 1 && index <= prs.length) {
+                resolve(index - 1); // Return array index, not PR number
+            }
+            else {
+                resolve(null);
+            }
+        });
+    });
+}
+// Ask user to approve or reject the review suggestion
+function askReviewApproval(suggestion) {
+    return new Promise((resolve) => {
+        console.log('\n💡 AI-suggested review:\n');
+        console.log(suggestion);
+        console.log('\n---');
+        console.log('1) ✅ Approve');
+        console.log('2) ❌ Reject');
+        console.log('3) ✍️ Edit');
+        console.log('4) Write your own review');
+        console.log('5) 🚪 Cancel');
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question(`\n👉 Choose an option [1-5]: `, (answer) => {
+            rl.close();
+            if (answer === '1') {
+                resolve('approve');
+            }
+            else if (answer === '2') {
+                resolve('reject');
+            }
+            else if (answer === '3') {
+                resolve('edit');
+            }
+            else if (answer === '4') {
+                resolve('custom');
+            }
+            else if (answer === '5') {
+                resolve('cancel');
+            }
+            else {
+                console.log('⚠️ Invalid selection. Defaulting to "approve".');
+                resolve('approve');
+            }
+        });
+    });
+}
+// Prompt for custom review input
+function promptCustomReview() {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question('\n📝 Enter your custom review:\n> ', (input) => {
+            rl.close();
+            resolve(input.trim());
+        });
+    });
+}
+export async function reviewPullRequestCmd(branch = 'main', showAll = false) {
+    try {
+        console.log("🔍 Fetching pull requests and diffs...");
+        const token = await ensureGitHubAuth();
+        const username = await getGitHubUsername(token);
+        const { owner, repo } = getRepoDetails();
+        console.log(`👤 Authenticated user: ${username}`);
+        console.log(`📦 GitHub repo: ${owner}/${repo}`);
+        console.log(`🔍 Filtering ${showAll ? "all" : "user-specific"} PRs for branch: ${branch}`);
+        const prsWithReviewRequested = await getPullRequestsForReview(token, owner, repo, username, branch, !showAll);
+        console.log(`🔍 Found ${prsWithReviewRequested.length} PR(s) requiring review.`);
+        if (prsWithReviewRequested.length === 0) {
+            console.log("⚠️ No PRs found with review requested.");
+            return;
+        }
+        const selectedIndex = await askUserToPickPR(prsWithReviewRequested.map(p => p.pr));
+        if (selectedIndex === null)
+            return;
+        const { pr, diff } = prsWithReviewRequested[selectedIndex];
+        let prDiff = diff;
+        if (!prDiff) {
+            console.log(`🔍 Fetching diff for PR #${pr.number}...`);
+            prDiff = await fetchPullRequestDiff(pr, token);
+        }
+        const result = await reviewModule.run({ content: prDiff });
+        const reviewSuggestion = result.content || 'No review suggestion generated.';
+        const reviewChoice = await askReviewApproval(reviewSuggestion);
+        let reviewEvent;
+        if (reviewChoice === 'approve') {
+            reviewEvent = 'APPROVE';
+            console.log(`✅ Review for PR #${pr.number} approved.`);
+            await submitReview(pr.number, reviewSuggestion, reviewEvent);
+        }
+        else if (reviewChoice === 'reject') {
+            reviewEvent = 'REQUEST_CHANGES';
+            console.log(`❌ Review for PR #${pr.number} rejected.`);
+            await submitReview(pr.number, reviewSuggestion, reviewEvent);
+        }
+        else if (reviewChoice === 'cancel') {
+            console.log(`🚪 Review process for PR #${pr.number} cancelled.`);
+            return; // Exit the function and cancel the review process
+        }
+        else {
+            reviewEvent = 'COMMENT';
+            const customReview = await promptCustomReview();
+            console.log(`💬 Custom review: ${customReview}`);
+            await submitReview(pr.number, customReview, reviewEvent);
+        }
+    }
+    catch (err) {
+        console.error("❌ Error reviewing PR:", err.message);
+    }
+}

package/dist/config.js

@@ -5,6 +5,7 @@ const defaultConfig = {
     model: 'llama3',
     language: 'ts',
     indexDir: INDEX_DIR, // Default index directory from constants
+    githubToken: '', // Add githubToken to default config
 };
 // Function to ensure the configuration directory exists
 function ensureConfigDir() {
@@ -57,6 +58,15 @@ export const Config = {
         writeConfig({ indexDir });
         console.log(`📁 Index directory set to: ${indexDir}`);
     },
+    // Get the GitHub token from the config
+    getGitHubToken() {
+        return readConfig().githubToken || null;
+    },
+    // Set the GitHub token in the config
+    setGitHubToken(token) {
+        writeConfig({ githubToken: token });
+        console.log("✅ GitHub token updated");
+    },
     // Show the current configuration
     show() {
         const cfg = readConfig();
@@ -64,5 +74,6 @@ export const Config = {
         console.log(`   Model     : ${cfg.model}`);
         console.log(`   Language  : ${cfg.language}`);
         console.log(`   Index dir : ${cfg.indexDir}`);
+        console.log(`   GitHub Token: ${cfg.githubToken ? '*****' : 'Not Set'}`);
     }
 };

package/dist/daemon/daemonBatch.js

@@ -8,7 +8,12 @@ import { log } from '../utils/log.js';
 import lockfile from 'proper-lockfile';
 import { summaryModule } from '../pipeline/modules/summaryModule.js';
 import { classifyFile } from '../fileRules/classifyFile.js';
+import { markFileAsSkippedByPath, selectUnprocessedFiles, updateFileWithSummaryAndEmbedding, } from '../db/sqlTemplates.js';
 const MAX_FILES_PER_BATCH = 5;
+/**
+ * Acquires a lock on the database to ensure that only one daemon batch
+ * can modify it at a time.
+ */
 async function lockDb() {
     try {
         return await lockfile.lock(DB_PATH);
@@ -18,15 +23,18 @@ async function lockDb() {
         throw err;
     }
 }
+/**
+ * Runs a daemon batch to process up to MAX_FILES_PER_BATCH unprocessed files.
+ * This includes:
+ * - Verifying file existence and validity
+ * - Generating summaries and embeddings if needed
+ * - Extracting functions from source files
+ * - Marking skipped files as necessary
+ */
 export async function runDaemonBatch() {
     log('🟡 Starting daemon batch...');
-    const rows = db.prepare(`
-    SELECT id, path, type, summary, indexed_at, last_modified, processing_status
-    FROM files
-    WHERE processing_status = 'unprocessed' OR summary IS NULL OR summary = ''
-    ORDER BY last_modified DESC
-    LIMIT ?
-  `).all(MAX_FILES_PER_BATCH);
+    // Selects up to MAX_FILES_PER_BATCH files that haven't been processed yet
+    const rows = db.prepare(selectUnprocessedFiles).all(MAX_FILES_PER_BATCH);
     if (rows.length === 0) {
         log('✅ No files left to process.');
         return false;
@@ -34,72 +42,62 @@ export async function runDaemonBatch() {
     const release = await lockDb();
     for (const row of rows) {
         log(`📂 Processing file: ${row.path}`);
+        // Skip if file is missing from the file system
         if (!fsSync.existsSync(row.path)) {
             log(`⚠️ Skipped missing file: ${row.path}`);
-            db.prepare(`UPDATE files SET processing_status = 'skipped' WHERE path = @path`).run({ path: row.path });
+            db.prepare(markFileAsSkippedByPath).run({ path: row.path });
             continue;
         }
+        // Skip if file is classified as something we don't process
         const classification = classifyFile(row.path);
         if (classification !== 'valid') {
             log(`⏭️ Skipping (${classification}): ${row.path}`);
-            db.prepare(`UPDATE files SET processing_status = 'skipped' WHERE path = @path`).run({ path: row.path });
+            db.prepare(markFileAsSkippedByPath).run({ path: row.path });
             continue;
         }
         try {
             const content = await fs.readFile(row.path, 'utf-8');
-            // 🧠 Only re-generate summary if it's missing or outdated
+            // Determine whether the file needs to be re-summarized
             const needsResummary = !row.summary ||
                 !row.indexed_at ||
                 (row.last_modified && new Date(row.last_modified) > new Date(row.indexed_at));
             if (needsResummary) {
                 log(`📝 Generating summary for ${row.path}...`);
+                // Generate a summary using the summary pipeline
                 const summaryResult = await summaryModule.run({ content, filepath: row.path });
                 const summary = summaryResult?.summary?.trim() || null;
                 let embedding = null;
+                // Generate an embedding from the summary (if present)
                 if (summary) {
                     const vector = await generateEmbedding(summary);
                     if (vector) {
                         embedding = JSON.stringify(vector);
                     }
                 }
-                db.prepare(`
-          UPDATE files
-          SET summary = @summary,
-              embedding = @embedding,
-              indexed_at = datetime('now')
-          WHERE path = @path
-        `).run({ summary, embedding, path: row.path });
+                // Update the file record with the new summary and embedding
+                db.prepare(updateFileWithSummaryAndEmbedding).run({
+                    summary,
+                    embedding,
+                    path: row.path,
+                });
                 log(`✅ Updated summary & embedding for ${row.path}`);
             }
             else {
                 log(`⚡ Skipped summary (up-to-date) for ${row.path}`);
             }
-            // 🧩 Extract functions and update processing status
+            // Extract top-level functions from the file and update the DB
             const extracted = await indexFunctionsForFile(row.path, row.id);
             if (extracted) {
-                db.prepare(`
-          UPDATE files
-          SET processing_status = 'extracted',
-              functions_extracted_at = datetime('now')
-          WHERE id = @id
-        `).run({ id: row.id });
                 log(`✅ Function extraction complete for ${row.path}\n`);
             }
             else {
-                // If no functions were found, set processing status to 'skipped' or 'failed'
-                db.prepare(`
-          UPDATE files
-          SET processing_status = 'failed',
-              functions_extracted_at = datetime('now')
-          WHERE id = @id
-        `).run({ id: row.id });
                 log(`ℹ️ No functions extracted for ${row.path}\n`);
             }
         }
         catch (err) {
             log(`❌ Failed: ${row.path}: ${err instanceof Error ? err.message : String(err)}\n`);
-            db.prepare(`UPDATE files SET processing_status = 'failed' WHERE path = @path`).run({ path: row.path });
         }
+        // Add a small delay to throttle processing
         await new Promise(resolve => setTimeout(resolve, 200));
     }
     await release();

package/dist/db/functionExtractors/extractFromJava.js

@@ -1,4 +1,8 @@
-// extractFromJava.ts
-export async function extractFromJava(filePath, content, fileId) {
+import { db } from '../client.js';
+import { markFileAsSkippedTemplate } from '../sqlTemplates.js';
+export async function extractFromJava(filePath, _content, fileId) {
     console.warn(`⛔️ Java extraction not implemented: ${filePath}`);
+    // Mark the file as skipped with the relevant status update
+    db.prepare(markFileAsSkippedTemplate).run({ id: fileId });
+    return false;
 }

package/dist/db/functionExtractors/extractFromJs.js

@@ -4,6 +4,8 @@ import { generateEmbedding } from '../../lib/generateEmbedding.js';
 import { db } from '../client.js';
 import path from 'path';
 import { log } from '../../utils/log.js';
+import fs from 'fs';
+import { markFileAsSkippedTemplate, markFileAsExtractedTemplate, markFileAsFailedTemplate } from '../sqlTemplates.js';
 function getFunctionName(node, parent, fileName) {
     if (node.id?.name)
         return node.id.name;
@@ -18,96 +20,104 @@ function getFunctionName(node, parent, fileName) {
     return `${fileName}:<anon>`;
 }
 export async function extractFromJS(filePath, content, fileId) {
-    const ast = parse(content, {
-        ecmaVersion: 'latest',
-        sourceType: 'module',
-        locations: true,
-    });
-    const functions = [];
-    walkAncestor(ast, {
-        FunctionDeclaration(node, ancestors) {
-            const parent = ancestors[ancestors.length - 2];
-            const name = getFunctionName(node, parent, path.basename(filePath));
-            functions.push({
-                name,
-                start_line: node.loc?.start.line ?? -1,
-                end_line: node.loc?.end.line ?? -1,
-                content: content.slice(node.start, node.end),
-            });
-        },
-        FunctionExpression(node, ancestors) {
-            const parent = ancestors[ancestors.length - 2];
-            const name = getFunctionName(node, parent, path.basename(filePath));
-            functions.push({
-                name,
-                start_line: node.loc?.start.line ?? -1,
-                end_line: node.loc?.end.line ?? -1,
-                content: content.slice(node.start, node.end),
-            });
-        },
-        ArrowFunctionExpression(node, ancestors) {
-            const parent = ancestors[ancestors.length - 2];
-            const name = getFunctionName(node, parent, path.basename(filePath));
-            functions.push({
-                name,
-                start_line: node.loc?.start.line ?? -1,
-                end_line: node.loc?.end.line ?? -1,
-                content: content.slice(node.start, node.end),
-            });
-        },
-    });
-    if (functions.length === 0) {
-        log(`⚠️ No functions found in: ${filePath}`);
-        return false;
-    }
-    log(`🔍 Found ${functions.length} functions in ${filePath}`);
-    for (const fn of functions) {
-        const embedding = await generateEmbedding(fn.content);
-        const result = db.prepare(`
-      INSERT INTO functions (
-        file_id, name, start_line, end_line, content, embedding, lang
-      ) VALUES (
-        @file_id, @name, @start_line, @end_line, @content, @embedding, @lang
-      )
-    `).run({
-            file_id: fileId,
-            name: fn.name,
-            start_line: fn.start_line,
-            end_line: fn.end_line,
-            content: fn.content,
-            embedding: JSON.stringify(embedding),
-            lang: 'js'
-        });
-        const callerId = result.lastInsertRowid;
-        const fnAst = parse(fn.content, {
+    try {
+        const code = fs.readFileSync(filePath, 'utf-8');
+        console.log(`[Debug] Attempting to parse: ${filePath}`);
+        console.log(`[Debug] First 3 lines:\n${code.split('\n').slice(0, 3).join('\n')}`);
+        const ast = parse(content, {
             ecmaVersion: 'latest',
             sourceType: 'module',
             locations: true,
         });
-        const calls = [];
-        walkAncestor(fnAst, {
-            CallExpression(node) {
-                if (node.callee?.type === 'Identifier' && node.callee.name) {
-                    calls.push({ calleeName: node.callee.name });
-                }
-            }
+        const functions = [];
+        walkAncestor(ast, {
+            FunctionDeclaration(node, ancestors) {
+                const parent = ancestors[ancestors.length - 2];
+                const name = getFunctionName(node, parent, path.basename(filePath));
+                functions.push({
+                    name,
+                    start_line: node.loc?.start.line ?? -1,
+                    end_line: node.loc?.end.line ?? -1,
+                    content: content.slice(node.start, node.end),
+                });
+            },
+            FunctionExpression(node, ancestors) {
+                const parent = ancestors[ancestors.length - 2];
+                const name = getFunctionName(node, parent, path.basename(filePath));
+                functions.push({
+                    name,
+                    start_line: node.loc?.start.line ?? -1,
+                    end_line: node.loc?.end.line ?? -1,
+                    content: content.slice(node.start, node.end),
+                });
+            },
+            ArrowFunctionExpression(node, ancestors) {
+                const parent = ancestors[ancestors.length - 2];
+                const name = getFunctionName(node, parent, path.basename(filePath));
+                functions.push({
+                    name,
+                    start_line: node.loc?.start.line ?? -1,
+                    end_line: node.loc?.end.line ?? -1,
+                    content: content.slice(node.start, node.end),
+                });
+            },
         });
-        for (const call of calls) {
-            db.prepare(`
-        INSERT INTO function_calls (caller_id, callee_name)
-        VALUES (@caller_id, @callee_name)
+        if (functions.length === 0) {
+            log(`⚠️ No functions found in: ${filePath}`);
+            db.prepare(markFileAsSkippedTemplate).run({ id: fileId });
+            return false;
+        }
+        log(`🔍 Found ${functions.length} functions in ${filePath}`);
+        for (const fn of functions) {
+            const embedding = await generateEmbedding(fn.content);
+            const result = db.prepare(`
+        INSERT INTO functions (
+          file_id, name, start_line, end_line, content, embedding, lang
+        ) VALUES (
+          @file_id, @name, @start_line, @end_line, @content, @embedding, @lang
+        )
       `).run({
-                caller_id: callerId,
-                callee_name: call.calleeName
+                file_id: fileId,
+                name: fn.name,
+                start_line: fn.start_line,
+                end_line: fn.end_line,
+                content: fn.content,
+                embedding: JSON.stringify(embedding),
+                lang: 'js'
+            });
+            const callerId = result.lastInsertRowid;
+            const fnAst = parse(fn.content, {
+                ecmaVersion: 'latest',
+                sourceType: 'module',
+                locations: true,
+            });
+            const calls = [];
+            walkAncestor(fnAst, {
+                CallExpression(node) {
+                    if (node.callee?.type === 'Identifier' && node.callee.name) {
+                        calls.push({ calleeName: node.callee.name });
+                    }
+                }
             });
+            for (const call of calls) {
+                db.prepare(`
+          INSERT INTO function_calls (caller_id, callee_name)
+          VALUES (@caller_id, @callee_name)
+        `).run({
+                    caller_id: callerId,
+                    callee_name: call.calleeName
+                });
+            }
+            log(`📌 Indexed function: ${fn.name} with ${calls.length} calls`);
         }
-        log(`📌 Indexed function: ${fn.name} with ${calls.length} calls`);
+        db.prepare(markFileAsExtractedTemplate).run({ id: fileId });
+        log(`✅ Marked functions as extracted for ${filePath}`);
+        return true;
+    }
+    catch (err) {
+        log(`❌ Failed to extract from: ${filePath}`);
+        log(`   ↳ ${String(err.message)}`);
+        db.prepare(markFileAsFailedTemplate).run({ id: fileId });
+        return false;
     }
-    db.prepare(`
-    UPDATE files 
-    SET processing_status = 'extracted'
-    WHERE id = @fileId
-  `).run({ fileId });
-    log(`✅ Marked functions as extracted for ${filePath}`);
-    return true;
 }

package/dist/db/functionExtractors/extractFromXML.js

@@ -1,4 +1,8 @@
-// extractFromJava.ts
-export async function extractFromXML(filePath, content, fileId) {
+import { db } from '../client.js';
+import { markFileAsSkippedTemplate } from '../sqlTemplates.js';
+export async function extractFromXML(filePath, _content, fileId) {
     console.warn(`⛔️ XML extraction not implemented: ${filePath}`);
+    // Mark the file as skipped with the relevant status update
+    db.prepare(markFileAsSkippedTemplate).run({ id: fileId });
+    return false;
 }

package/dist/db/functionExtractors/index.js

@@ -4,6 +4,7 @@ import { extractFromJava } from './extractFromJava.js';
 import { extractFromJS } from './extractFromJs.js';
 import { extractFromXML } from './extractFromXML.js';
 import { db } from '../client.js';
+import { markFileAsFailedTemplate, markFileAsSkippedByPath } from '../sqlTemplates.js';
 /**
  * Detects file type and delegates to the appropriate extractor.
  */
@@ -17,32 +18,21 @@ export async function extractFunctionsFromFile(filePath, content, fileId) {
         if (type === 'java') {
             log(`❌ Nothing extracted for ${filePath} due to missing implementation`);
             await extractFromJava(filePath, content, fileId);
-            // move into extract file
-            db.prepare(`
-        UPDATE files SET processing_status = 'skipped' WHERE id = @id
-      `).run({ id: fileId });
             return false;
         }
         if (type === 'xml') {
             log(`❌ Nothing extracted for ${filePath} due to missing implementation`);
             await extractFromXML(filePath, content, fileId);
-            // move into extract file
-            db.prepare(`
-        UPDATE files SET processing_status = 'skipped' WHERE id = @id
-      `).run({ id: fileId });
             return false;
         }
         log(`⚠️ Unsupported file type: ${type} for function extraction. Skipping ${filePath}`);
-        db.prepare(`
-      UPDATE files SET processing_status = 'skipped' WHERE id = @id
-    `).run({ id: fileId });
+        db.prepare(markFileAsSkippedByPath).run({ path: filePath });
         return false;
     }
     catch (error) {
         log(`❌ Failed to extract functions from ${filePath}: ${error instanceof Error ? error.message : error}`);
-        db.prepare(`
-      UPDATE files SET processing_status = 'failed' WHERE id = @id
-    `).run({ id: fileId });
+        // Use the sqlTemplate to mark the file as 'failed'
+        db.prepare(markFileAsFailedTemplate).run({ id: fileId });
         return false;
     }
 }

package/dist/db/sqlTemplates.js

@@ -51,3 +51,51 @@ export const insertFunctionCallTemplate = `
   INSERT INTO function_calls (caller_id, callee_name)
   VALUES (:caller_id, :callee_name)
 `;
+// Mark a file as unprocessed
+export const markFileAsUnprocessedTemplate = `
+  UPDATE files
+  SET processing_status = 'unprocessed',
+      functions_extracted_at = NULL
+  WHERE id = :id
+`;
+// Mark a file as extracted
+export const markFileAsExtractedTemplate = `
+  UPDATE files
+  SET processing_status = 'extracted',
+      functions_extracted_at = CURRENT_TIMESTAMP
+  WHERE id = :id
+`;
+// Mark a file as skipped (not extractable)
+export const markFileAsSkippedTemplate = `
+  UPDATE files
+  SET processing_status = 'skipped',
+      functions_extracted_at = NULL
+  WHERE id = :id
+`;
+// Mark a file as failed
+export const markFileAsFailedTemplate = `
+  UPDATE files
+  SET processing_status = 'failed',
+      functions_extracted_at = NULL
+  WHERE id = :id
+`;
+export const selectUnprocessedFiles = `
+  SELECT id, path, type, summary, indexed_at, last_modified, processing_status
+  FROM files
+  WHERE processing_status = 'unprocessed' OR summary IS NULL OR summary = ''
+  ORDER BY last_modified DESC
+  LIMIT ?
+`;
+export const markFileAsSkippedByPath = `
+  UPDATE files
+  SET processing_status = 'skipped',
+    functions_extracted_at = NULL
+  WHERE path = @path
+`;
+export const updateFileWithSummaryAndEmbedding = `
+  UPDATE files
+  SET summary = @summary,
+      embedding = @embedding,
+      indexed_at = datetime('now')
+  WHERE path = @path
+`;

package/dist/fileRules/fileClassifier.js

@@ -1,9 +1,48 @@
 // utils/fileClassifier.ts
 import path from 'path';
+/**
+ * Determines whether a file is likely to be a *generated* or *bundled* file,
+ * rather than handwritten source code.
+ *
+ * This helps filter out files that shouldn't be analyzed for user-authored logic,
+ * like minified JS bundles, Webpack chunks, TypeScript output, etc.
+ */
 export function isGeneratedOrBundledFile(filePath) {
     const base = path.basename(filePath);
-    const isMinified = /\.min\.(js|ts)$/.test(base); // ✅ New check
+    /**
+     * Minified file detection:
+     * Matches file names like `something.min.js` or `app.min.ts`.
+     * These are typically compiled output intended for production and are not original source code.
+     */
+    const isMinified = /\.min\.(js|ts)$/.test(base);
+    /**
+     * Hash-named or chunk file detection:
+     * Matches file names like `bundle.839abc.js`, `chunk.123abc.ts`, or `main-worker.js`.
+     * These are often created by bundlers like Webpack, Vite, or Rollup.
+     */
     const isHashNamed = /[-_.](worker|bundle|chunk|[a-f0-9]{6,})\.(js|ts)$/.test(base);
-    const isInOutputFolder = /[\\/]dist[\\/]|[\\/]build[\\/]|[\\/]assets[\\/]|[\\/]node_modules[\\/]|[\\/]lib[\\/]|[\\/]plugin[s]?[\\/]/i.test(filePath);
-    return isMinified || isHashNamed || isInOutputFolder;
+    /**
+     * Output folder detection:
+     * These folders are commonly used to store compiled or bundled output.
+     * Examples: `dist/`, `build/`, `assets/`, `node_modules/`, `plugins/`
+     *
+     * If a file is inside any of these folders, we consider it generated/bundled.
+     */
+    const outputDirs = ['dist', 'build', 'assets', 'node_modules', 'plugins'];
+    const isInKnownOutputFolder = outputDirs.some(dir => new RegExp(`[\\\\/]${dir}[\\\\/]`, 'i').test(filePath));
+    /**
+     * Special case: `lib/` folder
+     * The `lib` folder may contain either handwritten code or compiled output, depending on the project.
+     * To avoid over-filtering, we only treat files in `lib/` as generated if they also look minified or hashed.
+     */
+    const isInLib = /[\\/]lib[\\/]/i.test(filePath);
+    const isLikelyBundledLib = isInLib && (isMinified || isHashNamed);
+    /**
+     * Return true if *any* of the following conditions are met:
+     *  - The file looks minified (e.g., `.min.js`)
+     *  - The file has a hash or is a known bundle/chunk/worker
+     *  - The file is located in a known output directory
+     *  - The file is in `lib/` and has signs of being generated (minified or hashed)
+     */
+    return isMinified || isHashNamed || isInKnownOutputFolder || isLikelyBundledLib;
 }

package/dist/github/api.js

@@ -0,0 +1,43 @@
+export async function fetchOpenPullRequests(token, owner, repo) {
+    const url = `https://api.github.com/repos/${owner}/${repo}/pulls`;
+    const res = await fetch(url, {
+        headers: {
+            Authorization: `token ${token}`,
+            Accept: "application/vnd.github.v3+json",
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`GitHub API error: ${res.status} ${res.statusText}`);
+    }
+    const prs = await res.json();
+    return prs.map((pr) => ({
+        number: pr.number,
+        title: pr.title,
+        diff_url: pr.diff_url,
+    }));
+}
+export async function fetchPullRequestDiff(pr, token) {
+    const res = await fetch(pr.diff_url, {
+        headers: {
+            Authorization: `token ${token}`,
+            Accept: "application/vnd.github.v3.diff",
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`Error fetching PR diff: ${res.status} ${res.statusText}`);
+    }
+    return await res.text();
+}
+export async function getGitHubUsername(token) {
+    const res = await fetch('https://api.github.com/user', {
+        headers: {
+            Authorization: `token ${token}`,
+            Accept: "application/vnd.github.v3+json",
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`Error fetching user info: ${res.status} ${res.statusText}`);
+    }
+    const user = await res.json();
+    return user.login; // GitHub username
+}

package/dist/github/auth.js

@@ -0,0 +1,15 @@
+import { Config } from '../config.js';
+import { promptForToken } from './token.js';
+export async function ensureGitHubAuth() {
+    // First check if the token exists in the config
+    let token = Config.getGitHubToken();
+    if (token) {
+        return token; // Token already exists in config, return it
+    }
+    // Token doesn't exist in config, prompt the user for it
+    console.log("🔐 GitHub token not found.");
+    token = await promptForToken();
+    // Save the token in the config
+    Config.setGitHubToken(token.trim());
+    return token.trim();
+}

package/dist/github/github.js

@@ -0,0 +1,71 @@
+import { ensureGitHubAuth } from './auth.js';
+import { getRepoDetails } from './repo.js';
+export async function fetchOpenPullRequests(token, owner, repo) {
+    const url = `https://api.github.com/repos/${owner}/${repo}/pulls?state=open&per_page=100`;
+    const res = await fetch(url, {
+        headers: {
+            Authorization: `token ${token}`,
+            Accept: 'application/vnd.github.v3+json',
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`GitHub API error: ${res.status} ${res.statusText}`);
+    }
+    const prs = await res.json();
+    return prs.map((pr) => ({
+        number: pr.number,
+        title: pr.title,
+        url: pr.url,
+        diff_url: pr.diff_url,
+        draft: pr.draft,
+        merged_at: pr.merged_at,
+        base: pr.base,
+        requested_reviewers: pr.requested_reviewers,
+    }));
+}
+export async function getGitHubUsername(token) {
+    const res = await fetch('https://api.github.com/user', {
+        headers: {
+            Authorization: `token ${token}`,
+            Accept: "application/vnd.github.v3+json",
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`Error fetching user info: ${res.status} ${res.statusText}`);
+    }
+    const user = await res.json();
+    return user.login; // GitHub username
+}
+export async function fetchPullRequestDiff(pr, token) {
+    const res = await fetch(pr.diff_url, {
+        headers: {
+            Authorization: `token ${token}`,
+            Accept: "application/vnd.github.v3.diff",
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`Error fetching PR diff: ${res.status} ${res.statusText}`);
+    }
+    return await res.text();
+}
+export async function submitReview(prNumber, body, event = 'COMMENT') {
+    const token = await ensureGitHubAuth();
+    const { owner, repo } = getRepoDetails();
+    const url = `https://api.github.com/repos/${owner}/${repo}/pulls/${prNumber}/reviews`;
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+            Authorization: `token ${token}`,
+            Accept: 'application/vnd.github.v3+json',
+        },
+        body: JSON.stringify({
+            body,
+            event,
+        }),
+    });
+    if (!res.ok) {
+        const errorText = await res.text();
+        throw new Error(`Failed to submit review: ${res.status} ${res.statusText} - ${errorText}`);
+    }
+    console.log(`✅ Submitted ${event} review for PR #${prNumber}`);
+}

package/dist/github/githubAuthCheck.js

@@ -0,0 +1,17 @@
+import { ensureGitHubAuth } from './auth.js';
+import { getRepoDetails } from './repo.js';
+export async function validateGitHubTokenAgainstRepo() {
+    const token = await ensureGitHubAuth();
+    const { owner, repo } = getRepoDetails();
+    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}`, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+            'User-Agent': 'scai-cli',
+        },
+    });
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(`❌ Token is invalid or lacks access to ${owner}/${repo}. GitHub says: ${response.status} ${response.statusText}${error.message ? ` – ${error.message}` : ''}`);
+    }
+    return `✅ GitHub token is valid for ${owner}/${repo}`;
+}

package/dist/github/repo.js

@@ -0,0 +1,57 @@
+import path from 'path';
+import { execSync } from 'child_process';
+import { Config } from '../config.js';
+/**
+ * Executes a Git command inside the specified working directory.
+ */
+function runGitCommand(cmd, cwd) {
+    return execSync(cmd, { cwd, encoding: 'utf-8' }).trim();
+}
+/**
+ * Retrieves the owner and repo name from the Git remote URL inside the indexDir.
+ * This ensures we get the correct GitHub repo owner and name, regardless of current working directory.
+ */
+function getRepoOwnerAndNameFromGit(indexDir) {
+    try {
+        const originUrl = runGitCommand('git config --get remote.origin.url', indexDir);
+        console.log(`🔗 Git origin URL from '${indexDir}': ${originUrl}`);
+        const match = originUrl.match(/github\.com[:/](.+?)(?:\.git)?$/);
+        if (!match)
+            throw new Error("❌ Could not parse GitHub repo from origin URL.");
+        const [owner, repo] = match[1].split('/');
+        console.log(`✅ Parsed from Git: owner='${owner}', repo='${repo}'`);
+        return { owner, repo };
+    }
+    catch (error) {
+        console.warn(`⚠️ Failed to parse GitHub info from Git config in '${indexDir}': ${error instanceof Error ? error.message : error}`);
+        throw error;
+    }
+}
+/**
+ * Fallback: Extracts GitHub repo owner and name from the index directory path.
+ */
+function getRepoOwnerAndNameFromIndexDir(indexDir) {
+    const parts = path.resolve(indexDir).split(path.sep);
+    const repo = parts.pop();
+    const owner = parts.pop();
+    console.log(`📁 Parsed from indexDir: owner='${owner}', repo='${repo}'`);
+    return { owner, repo };
+}
+/**
+ * Get the GitHub repo details, always from the configured indexDir.
+ * Prefers Git config, falls back to parsing the path.
+ */
+export function getRepoDetails() {
+    const indexDir = Config.getIndexDir();
+    if (!indexDir) {
+        throw new Error("❌ indexDir is not configured.");
+    }
+    console.log(`📦 Resolving GitHub repo info from indexDir: ${indexDir}`);
+    try {
+        return getRepoOwnerAndNameFromGit(indexDir);
+    }
+    catch {
+        console.log("🔁 Falling back to extracting from indexDir path...");
+        return getRepoOwnerAndNameFromIndexDir(indexDir);
+    }
+}

package/dist/github/token.js

@@ -0,0 +1,14 @@
+// Utility function to prompt for GitHub token
+import readline from 'readline';
+export function promptForToken() {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question('Paste your GitHub Personal Access Token (scopes: `repo`): ', (token) => {
+            rl.close();
+            resolve(token);
+        });
+    });
+}

package/dist/github/types.js

@@ -0,0 +1 @@
+"use strict";

package/dist/index.js

@@ -22,6 +22,9 @@ import { runAskCommand } from './commands/AskCmd.js';
 import { runBackupCommand } from './commands/BackupCmd.js';
 import { runMigrateCommand } from "./commands/MigrateCmd.js";
 import { runInspectCommand } from "./commands/InspectCmd.js";
+import { reviewPullRequestCmd } from "./commands/ReviewCmd.js";
+import { promptForToken } from "./github/token.js";
+import { validateGitHubTokenAgainstRepo } from "./github/githubAuthCheck.js";
 // 🎛️ CLI Setup
 const cmd = new Command('scai')
     .version(version)
@@ -47,8 +50,59 @@ cmd
 defineSuggCommand(cmd);
 // 🔧 Group: Git-related commands
 const git = cmd.command('git').description('Git utilities');
+git
+    .command('review')
+    .description('Review an open pull request using AI')
+    .option('-a, --all', 'Show all PRs requiring a review (not just for the current user)', false) // New option for showing all PRs
+    .action(async (cmd) => {
+    const showAll = cmd.all; // Access the flag passed via command line
+    await reviewPullRequestCmd('main', showAll); // Pass the flag to the review function
+});
 // Register `sugg` under `git` group
 defineSuggCommand(git);
+// Add auth-related commands
+const auth = cmd.command('auth').description('GitHub authentication commands');
+auth
+    .command('check')
+    .description('Check if GitHub authentication is set up and valid')
+    .action(async () => {
+    try {
+        const token = Config.getGitHubToken();
+        if (!token) {
+            console.log('❌ GitHub authentication not found. Please set your token.');
+            return;
+        }
+        // Call the new check
+        const result = await validateGitHubTokenAgainstRepo();
+        console.log(result);
+    }
+    catch (err) {
+        console.error(typeof err === 'string' ? err : err.message);
+    }
+});
+auth
+    .command('reset')
+    .description('Reset GitHub authentication credentials')
+    .action(() => {
+    Config.setGitHubToken(''); // Clears the GitHub token from the config
+    console.log('🔄 GitHub authentication has been reset.');
+    // Check if the token is successfully removed
+    const token = Config.getGitHubToken();
+    if (!token) {
+        console.log('✅ Token successfully removed from configuration.');
+    }
+    else {
+        console.log('❌ Token still exists in the configuration.');
+    }
+});
+auth
+    .command('set')
+    .description('Set your GitHub Personal Access Token')
+    .action(async () => {
+    const token = await promptForToken();
+    Config.setGitHubToken(token.trim());
+    console.log('🔑 GitHub token set successfully.');
+});
 // 🛠️ Group: `gen` commands for content generation
 const gen = cmd.command('gen').description('Generate code-related output');
 gen

package/dist/pipeline/modules/reviewModule.js

@@ -0,0 +1,21 @@
+import { generate } from '../../lib/generate.js';
+import { Config } from '../../config.js';
+export const reviewModule = {
+    name: 'review',
+    description: 'Reviews code diff or PR content and provides feedback',
+    async run({ content, filepath }) {
+        const model = Config.getModel();
+        const prompt = `
+You are a senior software engineer reviewing a pull request. 
+Give clear, constructive feedback based on the code changes below.
+
+Changes:
+${content}
+`.trim();
+        const response = await generate({ content: prompt, filepath }, model);
+        return {
+            content: response.content,
+            filepath,
+        };
+    }
+};

package/dist/utils/fileTree.js

@@ -1,30 +1,31 @@
 import fs from 'fs';
 import path from 'path';
-const IGNORED_DIRS = new Set([
-    'node_modules', 'dist', '.git', '.vscode', 'coverage', 'build', 'out', 'logs', 'tmp'
-]);
-export function generateFileTree(dir, maxDepth = 3, currentDepth = 0, prefix = '') {
-    if (currentDepth > maxDepth)
+export function generateFocusedFileTree(rootDir, focusPath, maxDepth = 2) {
+    const absoluteFocus = path.resolve(focusPath);
+    const parentDir = path.dirname(absoluteFocus);
+    const relativeTitle = path.relative(rootDir, parentDir).replace(/\\/g, '/');
+    const tree = generateFileTree(parentDir, maxDepth, absoluteFocus);
+    return `📂 ${relativeTitle || '.'}\n${tree}`;
+}
+function generateFileTree(dir, depth, highlightPath, prefix = '') {
+    if (depth < 0)
         return '';
     let output = '';
-    const items = fs.readdirSync(dir, { withFileTypes: true })
-        .filter(item => !IGNORED_DIRS.has(item.name))
-        .sort((a, b) => {
-        // Directories first
-        if (a.isDirectory() && !b.isDirectory())
-            return -1;
-        if (!a.isDirectory() && b.isDirectory())
-            return 1;
-        return a.name.localeCompare(b.name);
-    });
-    for (const [i, item] of items.entries()) {
-        const isLast = i === items.length - 1;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const sorted = entries.sort((a, b) => Number(b.isDirectory()) - Number(a.isDirectory()));
+    sorted.forEach((entry, index) => {
+        const isLast = index === sorted.length - 1;
         const connector = isLast ? '└── ' : '├── ';
-        const childPrefix = prefix + (isLast ? '    ' : '│   ');
-        output += `${prefix}${connector}${item.name}\n`;
-        if (item.isDirectory()) {
-            output += generateFileTree(path.join(dir, item.name), maxDepth, currentDepth + 1, childPrefix);
+        const fullPath = path.join(dir, entry.name);
+        const isHighlighted = highlightPath && path.resolve(fullPath) === path.resolve(highlightPath);
+        if (entry.isDirectory()) {
+            output += `${prefix}${connector}${entry.name}/\n`;
+            output += generateFileTree(fullPath, depth - 1, highlightPath, prefix + (isLast ? '    ' : '│   '));
         }
-    }
+        else {
+            const name = isHighlighted ? `➡️ ${entry.name}` : entry.name;
+            output += `${prefix}${connector}${name}\n`;
+        }
+    });
     return output;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scai",
-  "version": "0.1.49",
+  "version": "0.1.51",
   "type": "module",
   "bin": {
     "scai": "./dist/index.js"