scai 0.1.97 → 0.1.99

package/dist/CHANGELOG.md

@@ -138,7 +138,12 @@ Type handling with the module pipeline
 * Improved CLI configuration settings with context-aware actions
 * Improved logging and added active repo change detection
 
-## 2025-08-23
+## 2025-08-24
 
-* Improved CLI configuration settings with context-aware actions
-* Added CLI configuration settings with context-aware actions and improved logging
+• Improved CLI review command with AI-generated suggestions and enhanced user interface.
+
+## 2025-08-26
+
+• Fixed bug where entire block was returned as a single line for multi-line comments
+• Add multi-line comment handling with ~90% accuracy
+• Update CLI config file to use codellama:13b model and 4096 context length

package/dist/commands/ReviewCmd.js

@@ -9,11 +9,11 @@ import os from 'os';
 import path from 'path';
 import { spawnSync } from 'child_process';
 import columnify from 'columnify';
+import { Spinner } from '../lib/spinner.js'; // adjust path as needed
 function truncate(str, length) {
     return str.length > length ? str.slice(0, length - 3) + '...' : str;
 }
 // Fetch open PRs with review requested
-import { Spinner } from '../lib/spinner.js'; // adjust path as needed
 export async function getPullRequestsForReview(token, owner, repo, username, branch = 'main', filterForUser = true) {
     const spinner = new Spinner('Fetching pull requests and diffs...');
     spinner.start();
@@ -87,7 +87,6 @@ function askUserToPickPR(prs) {
             ID: `#${pr.number}`,
             Title: chalk.gray(truncate(pr.title, 50)),
             Author: chalk.magentaBright(pr.user || '—'),
-            Status: pr.draft ? 'Draft' : 'Open',
             Created: pr.created_at?.split('T')[0] || '',
             'Requested Reviewers': pr.requested_reviewers?.length
                 ? pr.requested_reviewers.join(', ')
@@ -106,11 +105,12 @@ function askUserToPickPR(prs) {
             columnSplitter: '  ',
             headingTransform: (h) => chalk.cyan(h.toUpperCase()),
             config: {
+                '#': { maxWidth: 4 },
                 Title: { maxWidth: 50 },
                 'Requested Reviewers': { maxWidth: 30 },
                 'Actual Reviewers': { maxWidth: 30 },
                 Reviews: { maxWidth: 20 },
-            }
+            },
         }));
         const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
         rl.question(`\n👉 Choose a PR to review [1-${prs.length}]: `, (answer) => {
@@ -130,9 +130,9 @@ function askUserToPickPR(prs) {
 function askReviewMethod() {
     return new Promise((resolve) => {
         const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-        console.log("\n🔍 Choose review method:");
+        console.log(chalk.bold("\n🔍 Choose review method:\n"));
         console.log('1) Review whole PR at once');
-        console.log('2) Review chunk by chunk');
+        console.log('2) Review chunk by chunk\n');
         rl.question(`👉 Choose an option [1-2]: `, (answer) => {
             rl.close();
             resolve(answer === '2' ? 'chunk' : 'whole');
@@ -255,34 +255,134 @@ function colorDiffLine(line) {
         return chalk.yellow(line);
     return line;
 }
-// Review a single chunk
+function parseAISuggestions(aiOutput) {
+    return aiOutput
+        .split(/\n\d+\.\s/) // Split on "1. ", "2. ", "3. "
+        .map(s => s.trim())
+        .filter(Boolean)
+        .map(s => s.replace(/^💬\s*/, ''));
+}
+async function promptAIReviewSuggestions(aiOutput, chunkContent) {
+    // Strip first line if it's a summary like "Here are 4 suggestions:"
+    const lines = aiOutput.split('\n');
+    if (lines.length > 3 && /^here (are|is).*:?\s*$/i.test(lines[0])) {
+        aiOutput = lines.slice(1).join('\n').trim();
+    }
+    let suggestions = parseAISuggestions(aiOutput);
+    let selected = null;
+    while (!selected) {
+        const colorFuncs = [
+            chalk.cyan,
+            chalk.green,
+            chalk.yellow,
+            chalk.magenta,
+            chalk.blue,
+            chalk.red
+        ];
+        const rows = suggestions.map((s, i) => ({
+            No: String(i + 1).padStart(2),
+            Suggestion: colorFuncs[i % colorFuncs.length](s) // cycle through colors
+        }));
+        const rendered = columnify(rows, {
+            columns: ['No', 'Suggestion'],
+            showHeaders: false,
+            columnSplitter: '  ',
+            config: {
+                No: {
+                    align: 'right',
+                    dataTransform: (val) => chalk.cyan.bold(`${val}.`)
+                },
+                Suggestion: {
+                    maxWidth: 80,
+                    dataTransform: (val) => chalk.white(val)
+                }
+            }
+        });
+        console.log('\n' + chalk.yellow(chalk.bold('--- Review Suggestions ---')) + '\n');
+        console.log(rendered.replace(/\n/g, '\n\n'));
+        console.log();
+        console.log(chalk.gray('Select an option above or:'));
+        console.log(chalk.cyan('  r)') + ' Regenerate suggestions');
+        console.log(chalk.cyan('  c)') + ' Write custom review');
+        console.log(chalk.cyan('  s)') + ' Skip this chunk');
+        console.log(chalk.cyan('  q)') + ' Cancel review');
+        const range = `1-${suggestions.length}`;
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const answer = await new Promise(resolve => rl.question(chalk.bold(`\n👉 Choose [${range},r,c,s,q]: `), resolve));
+        rl.close();
+        const trimmed = answer.trim().toLowerCase();
+        if (['1', '2', '3'].includes(trimmed)) {
+            const idx = parseInt(trimmed, 10) - 1;
+            selected = suggestions[idx];
+            const rlEdit = readline.createInterface({ input: process.stdin, output: process.stdout });
+            const editAnswer = await new Promise(resolve => rlEdit.question('✍️ Edit this suggestion before submitting? [y/N]: ', resolve));
+            rlEdit.close();
+            if (editAnswer.trim().toLowerCase() === 'y') {
+                selected = await promptEditReview(selected);
+            }
+        }
+        else if (trimmed === 'r') {
+            console.log(chalk.yellow('\nRegenerating suggestions...\n'));
+            const newSuggestion = await reviewModule.run({ content: chunkContent });
+            const newOutput = newSuggestion.content || aiOutput;
+            suggestions = parseAISuggestions(newOutput);
+        }
+        else if (trimmed === 'c') {
+            selected = await promptCustomReview();
+        }
+        else if (trimmed === 's') {
+            return "skip";
+        }
+        else if (trimmed === 'q') {
+            console.log(chalk.red('\nReview cancelled.\n'));
+            return "cancel";
+        }
+        else {
+            console.log(chalk.red('\n⚠️ Invalid input. Try again.\n'));
+        }
+    }
+    console.log(chalk.green('\n✅ Selected suggestion:\n'), selected, '\n');
+    const action = await askReviewApproval();
+    if (action === 'approve')
+        return selected;
+    if (action === 'reject')
+        return selected;
+    if (action === 'edit')
+        return await promptEditReview(selected);
+    if (action === 'custom')
+        return await promptCustomReview();
+    if (action === 'cancel') {
+        console.log(chalk.yellow('Review cancelled.\n'));
+        return "cancel";
+    }
+    return null;
+}
 export async function reviewChunk(chunk, chunkIndex, totalChunks) {
-    const lines = chunk.content.split('\n');
-    const coloredDiff = lines.map(colorDiffLine).join('\n');
     console.log(chalk.gray('\n' + '━'.repeat(60)));
     console.log(`📄 ${chalk.bold('File')}: ${chalk.cyan(chunk.filePath)}`);
     console.log(`🔢 ${chalk.bold('Chunk')}: ${chunkIndex + 1} of ${totalChunks}`);
+    // Build colored diff
+    const lines = chunk.content.split('\n');
+    const coloredDiff = lines.map(colorDiffLine).join('\n');
+    // 1️⃣ Run the AI review
     const suggestion = await reviewModule.run({
         content: chunk.content,
         filepath: chunk.filePath
     });
-    const summary = suggestion.content?.trim() || 'AI review summary not available.';
-    console.log(`🔍 ${chalk.bold('Summary')}: ${summary}`);
+    const aiOutput = suggestion.content?.trim() || '1. AI review summary not available.';
+    // 2️⃣ Show the diff
     console.log(`\n${chalk.bold('--- Diff ---')}\n`);
     console.log(coloredDiff);
-    console.log(`\n${chalk.bold('--- AI Review ---')}\n`);
-    console.log(chalk.blue(`💬 ${summary}`));
-    console.log(chalk.gray('━'.repeat(60)));
-    const choice = await promptChunkReviewMenu();
-    if (choice === 'edit') {
-        const edited = await promptEditReview(summary); // edit based on the suggestion
-        return { choice: edited, summary: edited };
+    // 3️⃣ Prompt user to pick/skip/cancel
+    const selectedReview = await promptAIReviewSuggestions(aiOutput, chunk.content);
+    if (selectedReview === "cancel") {
+        return { choice: "cancel", summary: "" };
     }
-    else if (choice === 'skip') {
-        await waitForSpaceOrQ(); // pause between chunks
-        return { choice: 'cancel', summary }; // skip this one
+    if (selectedReview === "skip") {
+        await waitForSpaceOrQ();
+        return { choice: "skip", summary: "" };
     }
-    return { choice, summary };
+    return { choice: selectedReview ?? "", summary: selectedReview ?? "" };
 }
 function waitForSpaceOrQ() {
     return new Promise(resolve => {
@@ -371,24 +471,34 @@ export async function reviewPullRequestCmd(branch = 'main', showAll = false) {
         const reviewMethod = chunks.length > 1 ? await askReviewMethod() : 'chunk';
         let reviewComments = [];
         if (reviewMethod === 'whole') {
-            const suggestion = await reviewModule.run({ content: diff, filepath: 'Whole PR Diff' });
-            console.log(chalk.yellowBright("Suggestion: ", suggestion));
+            const result = await reviewModule.run({ content: diff, filepath: 'Whole PR Diff' });
+            console.log(chalk.yellowBright("Raw AI output:\n"), result.content);
+            // Use the parsed array for selecting or displaying suggestions
+            let suggestions = result.suggestions;
+            if (suggestions && suggestions.length > 3 && /here (are|is) \d+ suggestions/i.test(suggestions[0])) {
+                suggestions = suggestions.slice(1);
+            }
             const finalReviewChoice = await askReviewApproval();
             let reviewText = '';
+            // Pick the first suggestion as default if any exist
+            if (suggestions && suggestions.length > 0) {
+                reviewText = suggestions[0];
+            }
             if (finalReviewChoice === 'approve') {
                 reviewText = 'PR approved';
-                await submitReview(pr.number, suggestion.content, 'APPROVE');
+                await submitReview(pr.number, reviewText, 'APPROVE');
             }
             else if (finalReviewChoice === 'reject') {
                 reviewText = 'Changes requested';
-                await submitReview(pr.number, suggestion.content, 'REQUEST_CHANGES');
+                await submitReview(pr.number, reviewText, 'REQUEST_CHANGES');
             }
             else if (finalReviewChoice === 'custom') {
                 reviewText = await promptCustomReview();
                 await submitReview(pr.number, reviewText, 'COMMENT');
             }
             else if (finalReviewChoice === 'edit') {
-                reviewText = await promptEditReview(suggestion.content);
+                // let user edit the AI suggestion
+                reviewText = await promptEditReview(reviewText);
                 await submitReview(pr.number, reviewText, 'COMMENT');
             }
         }
@@ -398,7 +508,11 @@ export async function reviewPullRequestCmd(branch = 'main', showAll = false) {
             for (let i = 0; i < chunks.length; i++) {
                 const chunk = chunks[i];
                 const { choice, summary } = await reviewChunk(chunk, i, chunks.length);
-                if (choice === 'cancel' || choice === 'skip') {
+                if (choice === 'cancel') {
+                    console.log(chalk.red(`🚫 Review cancelled at chunk ${i + 1}`));
+                    return; // exit reviewPullRequestCmd early
+                }
+                if (choice === 'skip') {
                     console.log(chalk.gray(`⏭️ Skipped chunk ${i + 1}`));
                     continue;
                 }

package/dist/commands/SummaryCmd.js

@@ -3,11 +3,11 @@ import path from 'path';
 import readline from 'readline';
 import { queryFiles, indexFile } from '../db/fileIndex.js';
 import { summaryModule } from '../pipeline/modules/summaryModule.js';
-import { styleOutput } from '../utils/summarizer.js';
 import { detectFileType } from '../fileRules/detectFileType.js';
 import { generateEmbedding } from '../lib/generateEmbedding.js';
 import { sanitizeQueryForFts } from '../utils/sanitizeQuery.js';
 import { getDbForRepo } from '../db/client.js';
+import { styleText } from '../utils/outputFormatter.js';
 export async function summarizeFile(filepath) {
     let content = '';
     let filePathResolved;
@@ -40,7 +40,7 @@ export async function summarizeFile(filepath) {
         const match = matches.find(row => path.resolve(row.path) === filePathResolved);
         if (match?.summary) {
             console.log(`🧠 Cached summary for ${filepath}:\n`);
-            console.log(styleOutput(match.summary));
+            console.log(styleText(match.summary));
             return;
         }
         try {
@@ -73,7 +73,7 @@ export async function summarizeFile(filepath) {
             console.warn('⚠️ No summary generated.');
             return;
         }
-        console.log(styleOutput(response.summary));
+        console.log(styleText(response.summary));
         if (filePathResolved) {
             const fileType = detectFileType(filePathResolved);
             indexFile(filePathResolved, response.summary, fileType);

package/dist/config.js

@@ -6,8 +6,8 @@ import { normalizePath } from './utils/normalizePath.js';
 import chalk from 'chalk';
 import { getHashedRepoKey } from './utils/repoKey.js';
 const defaultConfig = {
-    model: 'llama3',
-    contextLength: 8192,
+    model: 'codellama:13b',
+    contextLength: 4096,
     language: 'ts',
     indexDir: '',
     githubToken: '',

package/dist/lib/generate.js

@@ -5,9 +5,7 @@ export async function generate(input, model) {
     const contextLength = readConfig().contextLength ?? 8192;
     let prompt = input.content;
     if (prompt.length > contextLength) {
-        console.warn(`⚠️ Warning: Input prompt length (${prompt.length}) exceeds model context length (${contextLength}). ` +
-            `The model may truncate or not handle the entire prompt. Truncating input.`);
-        prompt = prompt.slice(0, contextLength);
+        console.warn(`⚠️ Warning: Input prompt length (${prompt.length}) exceeds model context length (${contextLength}). `);
     }
     const spinner = new Spinner(`🧠 Thinking with ${model}...`);
     spinner.start();

package/dist/modelSetup.js

@@ -82,7 +82,6 @@ async function ensureOllamaRunning() {
         return;
     }
     console.log(chalk.yellow('⚙️  Ollama is not running. Attempting to start it...'));
-    let ollamaStarted = false;
     try {
         const child = spawn('ollama', ['serve'], {
             detached: true,

package/dist/pipeline/modules/preserveCodeModule.js

@@ -8,126 +8,131 @@ export const preserveCodeModule = {
             throw new Error("Requires `originalContent`.");
         const syntax = {
             singleLine: ["//"],
-            multiLine: [{ start: "/*", end: "*/" }]
+            multiLine: [{ start: "/*", end: "*/" }, { start: "/**", end: "*/" }]
         };
         // --- Normalize line endings ---
         const normalize = (txt) => txt.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
         const origLines = normalize(originalContent).split("\n");
         const newLines = normalize(content).split("\n");
-        // Detect if a line is a comment line, and classify
+        // --- Classify line ---
         let inBlockComment = false;
+        let blockLines = [];
         const classifyLine = (line) => {
             const trimmed = line.trimStart();
-            // Single-line
+            // --- Single-line comment ---
             for (const s of syntax.singleLine) {
                 if (trimmed.startsWith(s))
-                    return "single-comment";
+                    return line; // return actual line
             }
-            // Multi-line start/end
+            // --- Multi-line comment ---
             for (const { start, end } of syntax.multiLine) {
-                if (trimmed.startsWith(start) && trimmed.includes(end)) {
-                    return "multi-comment (start+end)";
-                }
-                if (trimmed.startsWith(start)) {
-                    inBlockComment = true;
-                    return "multi-comment (start)";
+                if (!inBlockComment) {
+                    if (trimmed.startsWith(start) && trimmed.includes(end)) {
+                        return line; // entire block on a single line
+                    }
+                    if (trimmed.startsWith(start)) {
+                        inBlockComment = true;
+                        blockLines = [line];
+                        return line; // start of multi-line block
+                    }
                 }
-                if (inBlockComment) {
+                else {
+                    blockLines.push(line);
                     if (trimmed.includes(end)) {
                         inBlockComment = false;
-                        return "multi-comment (end)";
+                        const fullBlock = blockLines.join("\n");
+                        blockLines = [];
+                        return fullBlock; // return entire multi-line block
                     }
-                    return "multi-comment (mid)";
+                    return ""; // middle lines, wait until block ends
                 }
             }
             return "code";
         };
-        // Collect consecutive comment lines as one block
-        function collectBlock(lines, startIndex) {
-            const block = [];
-            let i = startIndex;
-            while (i < lines.length && classifyLine(lines[i]) !== "code") {
-                block.push(lines[i]);
-                i++;
-            }
-            return block;
-        }
-        const trimBlock = (block) => block.map(line => line.trim());
-        const blocksEqual = (a, b) => JSON.stringify(trimBlock(a)) === JSON.stringify(trimBlock(b));
-        const fixedLines = [];
-        let origIndex = 0;
-        let newIndex = 0;
-        // Track all inserted comment blocks globally
-        const insertedBlocks = new Set();
-        while (origIndex < origLines.length) {
-            const origLine = origLines[origIndex];
-            // If this is a comment line in original or model
-            if (classifyLine(origLine) !== "code" || classifyLine(newLines[newIndex] ?? "") !== "code") {
-                const origBlock = collectBlock(origLines, origIndex);
-                const modelBlock = collectBlock(newLines, newIndex);
-                // Merge: model block first, then any orig lines not in model
-                const seen = new Set(trimBlock(modelBlock));
-                const mergedBlock = [...modelBlock];
-                for (const line of origBlock) {
-                    if (!seen.has(line.trim())) {
-                        mergedBlock.push(line);
-                    }
+        // --- Helper: collect comment blocks into map ---
+        function collectCommentsMap(lines) {
+            const map = new Map();
+            let commentBuffer = [];
+            for (const line of lines) {
+                const type = classifyLine(line);
+                if (type && type !== "code") {
+                    // Collect comment lines
+                    commentBuffer.push(type.trim());
                 }
-                // Create a key for duplicate detection
-                const mergedKey = JSON.stringify(trimBlock(mergedBlock));
-                // Insert only if this block was never inserted before
-                if (!insertedBlocks.has(mergedKey)) {
-                    fixedLines.push(...mergedBlock);
-                    insertedBlocks.add(mergedKey);
-                }
-                else {
-                    console.log("Skipping duplicate block (already inserted)");
+                else if (type === "code") {
+                    // Flush buffer when hitting code
+                    if (commentBuffer.length > 0) {
+                        const key = line.trim().toLowerCase();
+                        if (!map.has(key))
+                            map.set(key, new Set());
+                        // Join consecutive comments into one block
+                        const commentBlock = commentBuffer.join("\n").toLowerCase();
+                        map.get(key).add(commentBlock);
+                        commentBuffer = [];
+                    }
                 }
-                // Advance indices past the entire blocks
-                origIndex += origBlock.length;
-                newIndex += modelBlock.length;
-                continue;
             }
-            // Non-comment line
-            const newLine = newLines[newIndex] ?? "";
-            fixedLines.push(origLine.trim() === newLine.trim() ? newLine : origLine);
-            origIndex++;
-            newIndex++;
+            // Flush remaining comments at EOF
+            if (commentBuffer.length > 0) {
+                const key = "";
+                if (!map.has(key))
+                    map.set(key, new Set());
+                const commentBlock = commentBuffer.join("\n").toLowerCase();
+                map.get(key).add(commentBlock);
+            }
+            return map;
         }
-        // Add any remaining original lines if model ran out
-        while (origIndex < origLines.length) {
-            fixedLines.push(origLines[origIndex++]);
+        // --- Step 1: Collect comments ---
+        const modelComments = collectCommentsMap(newLines); // model first
+        const origComments = collectCommentsMap(origLines); // original
+        // --- Step 2: Remove duplicates ---
+        for (const [key, commentSet] of modelComments.entries()) {
+            if (origComments.has(key)) {
+                commentSet.forEach(c => {
+                    origComments.get(key).delete(c.trim().toLowerCase());
+                });
+                if (origComments.get(key).size === 0)
+                    origComments.delete(key);
+            }
         }
-        // Add trailing comments from model if any
-        while (newIndex < newLines.length) {
-            if (classifyLine(newLines[newIndex]) !== "code") {
-                fixedLines.push(newLines[newIndex]);
+        // --- Step 3: Build fixed lines with model comments inserted above original ---
+        const fixedLines = [];
+        for (const origLine of origLines) {
+            const key = origLine.trim().toLowerCase();
+            // Insert model comment blocks if any
+            if (modelComments.has(key)) {
+                modelComments.get(key).forEach(block => {
+                    const lines = block.split("\n");
+                    for (const line of lines) {
+                        if (!fixedLines.includes(line)) {
+                            fixedLines.push(line);
+                            console.log(chalk.blue("Inserted comment:"), line.trim());
+                        }
+                        else {
+                            console.log(chalk.gray("Skipped duplicate comment:"), line.trim());
+                        }
+                    }
+                });
             }
-            newIndex++;
+            fixedLines.push(origLine);
         }
         // --- Logging for debugging ---
         console.log(chalk.bold.blue("\n=== LINE CLASSIFICATION (original) ==="));
         origLines.forEach((line, i) => {
             const type = classifyLine(line);
-            const colored = type === "code"
-                ? chalk.green(line)
-                : chalk.yellow(line);
+            const colored = type === "code" ? chalk.green(line) : chalk.yellow(line);
             console.log(`${i + 1}: ${colored} ${chalk.gray(`[${type}]`)}`);
         });
         console.log(chalk.bold.blue("\n=== LINE CLASSIFICATION (model) ==="));
         newLines.forEach((line, i) => {
             const type = classifyLine(line);
-            const colored = type === "code"
-                ? chalk.green(line)
-                : chalk.yellow(line);
+            const colored = type === "code" ? chalk.green(line) : chalk.yellow(line);
             console.log(`${i + 1}: ${colored} ${chalk.gray(`[${type}]`)}`);
         });
         console.log(chalk.bold.blue("\n=== FIXED CONTENT ==="));
         fixedLines.forEach((line, i) => {
             const type = classifyLine(line);
-            const colored = type === "code"
-                ? chalk.green(line)
-                : chalk.yellow(line);
+            const colored = type === "code" ? chalk.green(line) : chalk.yellow(line);
             console.log(`${i + 1}: ${colored} ${chalk.gray(`[${type}]`)}`);
         });
         return { content: fixedLines.join("\n"), filepath };

package/dist/pipeline/modules/reviewModule.js

@@ -6,21 +6,32 @@ export const reviewModule = {
     async run({ content, filepath }) {
         const model = Config.getModel();
         const prompt = `
-You are a senior software engineer reviewing a pull request. 
-ALWAYS make 3 concise suggestions for improvements based on the input code diff.
-Use this format ONLY and output ONLY those suggestions:
+Suggest ALWAYS 3 concise suggestions for improvements based on the input code diff.
 
-1. ...
-2. ...
-3. ...
+- Use one of these types for each suggestion: style, refactor, bug, docs, test
+- Keep each message short, clear, and actionable
+
+Format your response exactly as:
+
+1. <type>: <message>
+2. <type>: <message>
+3. <type>: <message>
 
 Changes:
 ${content}
 `.trim();
         const response = await generate({ content: prompt, filepath }, model);
+        // Parse response: only keep numbered lines
+        const lines = response.content
+            .split('\n')
+            .map(line => line.trim())
+            .filter(line => /^\d+\.\s+/.test(line));
+        // Remove numbering and any surrounding quotes
+        const suggestions = lines.map(line => line.replace(/^\d+\.\s+/, '').replace(/^"(.*)"$/, '$1').trim());
         return {
             content: response.content,
             filepath,
+            suggestions
         };
     }
 };

package/dist/utils/outputFormatter.js

@@ -0,0 +1,53 @@
+import columnify from "columnify";
+/**
+ * Format structured rows for terminal output.
+ */
+export function styleRows(rows, options = {}) {
+    if (!rows || rows.length === 0)
+        return "";
+    const terminalWidth = process.stdout.columns || 80;
+    const { maxWidthFraction = 2 / 3 } = options;
+    return columnify(rows, {
+        columnSplitter: "  ",
+        maxLineWidth: terminalWidth,
+        config: Object.fromEntries(Object.keys(rows[0]).map((key) => [
+            key,
+            { maxWidth: Math.floor(terminalWidth * maxWidthFraction), align: "left" },
+        ])),
+    });
+}
+/**
+ * Format a plain string for terminal output (wraps lines to terminal width).
+ */
+export function styleText(text, options = {}) {
+    const terminalWidth = process.stdout.columns || 80;
+    const { maxWidthFraction = 2 / 3 } = options;
+    const maxWidth = Math.floor(terminalWidth * maxWidthFraction);
+    // Wrap each line to maxWidth
+    const wrapped = text
+        .split("\n")
+        .map((line) => {
+        if (line.length <= maxWidth)
+            return line;
+        const chunks = [];
+        let start = 0;
+        while (start < line.length) {
+            chunks.push(line.slice(start, start + maxWidth));
+            start += maxWidth;
+        }
+        return chunks.join("\n");
+    })
+        .join("\n");
+    return wrapped;
+}
+/**
+ * Parse numbered suggestions or key-value text into rows for columnify.
+ */
+export function parseAndStyleSuggestions(text, options = {}) {
+    // Simple parser: each line becomes { No: n, Suggestion: line }
+    const rows = text
+        .trim()
+        .split("\n")
+        .map((line, idx) => ({ No: (idx + 1).toString(), Suggestion: line }));
+    return styleRows(rows, options);
+}

package/dist/utils/splitCodeIntoChunk.js

@@ -4,24 +4,41 @@ export function splitCodeIntoChunks(text, maxTokens) {
     const chunks = [];
     let currentChunkLines = [];
     let currentTokens = 0;
+    let inMultiComment = false;
+    const start = '/*';
+    const end = '*/';
     for (const line of lines) {
+        const trimmed = line.trim();
+        // --- Track multi-line comments ---
+        if (trimmed.includes(start) && !trimmed.includes(end)) {
+            // Starts a block comment but does not end on the same line
+            inMultiComment = true;
+        }
+        else if (trimmed.includes(start) && trimmed.includes(end)) {
+            // Inline comment: "/* ... */" on same line → ignore, don't toggle state
+            // do nothing with inMultiComment
+        }
+        else if (trimmed.includes(end)) {
+            // End of a block comment
+            inMultiComment = false;
+        }
         const lineTokens = encode(line + '\n').length;
         if (currentTokens + lineTokens > maxTokens) {
-            // Try to split at a more natural point
+            // Split at natural points but never inside a multi-line comment
             let splitIndex = currentChunkLines.length;
             for (let i = currentChunkLines.length - 1; i >= 0; i--) {
-                const trimmed = currentChunkLines[i].trim();
-                if (trimmed === '' ||
-                    trimmed.startsWith('function ') ||
-                    trimmed.startsWith('class ') ||
-                    trimmed.endsWith('}') ||
-                    trimmed.endsWith(';')) {
+                const t = currentChunkLines[i].trim();
+                if (!inMultiComment &&
+                    (t === '' ||
+                        t.startsWith('function ') ||
+                        t.startsWith('class ') ||
+                        t.endsWith('}') ||
+                        t.endsWith(';'))) {
                     splitIndex = i + 1;
                     break;
                 }
             }
             chunks.push(currentChunkLines.slice(0, splitIndex).join('\n'));
-            // Move leftover lines into the next chunk
             currentChunkLines = currentChunkLines.slice(splitIndex);
             currentTokens = encode(currentChunkLines.join('\n')).length;
         }

package/package.json

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

package/dist/utils/summarizer.js

@@ -1,17 +0,0 @@
-import columnify from "columnify";
-export function styleOutput(summaryText) {
-    const terminalWidth = process.stdout.columns || 80;
-    // Split by line to simulate multiple rows instead of one long wrapped field
-    const lines = summaryText.trim().split('\n').map(line => ({ Summary: line }));
-    const formatted = columnify(lines, {
-        columnSplitter: '  ',
-        maxLineWidth: terminalWidth,
-        config: {
-            Summary: {
-                maxWidth: Math.floor((terminalWidth * 2) / 3),
-                align: "left",
-            },
-        },
-    });
-    return formatted;
-}