scai 0.1.127 → 0.1.128

package/README.md

@@ -12,14 +12,42 @@ SCAI is your AI coding companion in the terminal. Stay focused on coding while S
 > ⚠️ **Alpha Version Notice**
 > If you have previously installed SCAI, please run:
 >
-> ```bash
+> bash
 > scai db reset && scai index start
-> ```
+> 
 >
 > before using this version.
 
 ---
 
+## 🧠 Why SCAI?
+
+SCAI is not just another AI tool — it's a **developer-first**, **privacy-focused**, and **local-first** coding companion. Here's why SCAI stands out:
+
+### 🔐 **100% Local & Private by Design**
+
+Unlike cloud-based AI tools, SCAI runs entirely on your machine. No data leaves your environment — making it ideal for **sensitive codebases** and **GDPR-compliant workflows**.
+
+### 🧠 **Deep Code Understanding**
+
+SCAI doesn't just parse code — it **understands** it. With background indexing, static analysis, and language-aware parsing, SCAI helps you explore, refactor, and debug with confidence.
+
+### 📦 **No Token Costs or API Keys**
+
+SCAI works offline, with **zero token usage**. You don’t pay for API calls or subscribe to cloud services. Just install and go.
+
+### 🛠️ **Developer-Focused Toolset**
+
+From commit message generation to architecture summaries, SCAI integrates directly into your workflow. It's built for developers, by developers.
+
+### 🇩🇰 **Built in Denmark/EU**
+
+SCAI is developed in the European Union, ensuring compliance with data protection laws and a focus on privacy-first development.
+
+> ✅ SCAI is your **AI coding assistant that respects your privacy**, enhances your productivity, and works **entirely offline**.
+
+---
+
 ## 🗣️ Language Support (Important)
 
 SCAI is currently **tested and validated only on the following languages**:
@@ -36,11 +64,11 @@ Other languages may work partially, but analysis quality, indexing accuracy, and
 
 ### 1️⃣ Install & Initialize
 
-```bash
+bash
 npm install -g scai
 scai init
 scai index start
-```
+
 
 This initializes local models (recommended: `qwen3-coder:30b`) and starts indexing your code repository.
 

package/dist/agents/MainAgent.js

@@ -1,5 +1,6 @@
 import { builtInModules } from "../pipeline/registry/moduleRegistry.js";
 import { logInputOutput } from "../utils/promptLogHelper.js";
+import { planResolverStep } from "./planResolverStep.js";
 import { infoPlanGen } from "./infoPlanGenStep.js";
 import { understandIntentStep } from "./understandIntentStep.js";
 import { structuralAnalysisStep } from "./structuralAnalysisStep.js";
@@ -19,17 +20,14 @@ function startTimer() {
     return () => Date.now() - start;
 }
 function logLine(phase, step, ms, desc) {
-    // Clear current line (removes leftover spinner)
     process.stdout.write('\r\x1b[K');
     const suffix = desc ? ` — ${desc}` : "";
     const timing = typeof ms === "number" ? ` (${ms}ms)` : "";
     console.log(`[AGENT] ${phase} :: ${step}${suffix}${timing}`);
 }
-/** Helper to display messages to the user from the agent */
 function userOutput(message) {
     console.log(`[USER OUTPUT] ${message}`);
 }
-/** Helper to display messages with phase context */
 function userPhaseOutput(phase, message) {
     console.log(`[USER OUTPUT] [${phase}] ${message}`);
 }
@@ -41,7 +39,7 @@ function resolveModuleForAction(action) {
 /* ───────────────────────── agent ───────────────────────── */
 export class MainAgent {
     constructor(context) {
-        this.spinner = new Spinner(); // spinner for user feedback
+        this.spinner = new Spinner();
         this.runCount = 0;
         this.maxRuns = 2;
         this.context = context;
@@ -50,26 +48,22 @@ export class MainAgent {
     /* ───────────── step executor ───────────── */
     async executeStep(step, input) {
         const stop = startTimer();
-        if (input.context) {
-            input.context.currentStep = step;
-        }
+        this.context.currentStep = step;
         const mod = resolveModuleForAction(step.action);
         if (!mod) {
             logLine("EXECUTE", step.action, stop(), "skipped (missing module)");
             return {
                 query: input.query,
                 content: input.content,
-                data: { skipped: true },
-                context: input.context
+                data: { skipped: true }
             };
         }
         try {
-            // Update spinner text for user
             this.spinner.update(`Running step: ${step.action}`);
             const output = await mod.run({
                 query: step.description ?? input.query,
                 content: input.data ?? input.content,
-                context: input.context
+                context: this.context
             });
             if (!output) {
                 throw new Error(`Module "${mod.name}" returned empty output`);
@@ -77,8 +71,7 @@ export class MainAgent {
             logLine("EXECUTE", step.action, stop());
             return {
                 query: step.description ?? input.query,
-                data: output.data,
-                context: input.context
+                data: output.data
             };
         }
         catch (err) {
@@ -92,14 +85,12 @@ export class MainAgent {
         const stopRun = startTimer();
         logLine("RUN", `start #${this.runCount}`);
         logInputOutput("GlobalContext (structured)", "input", this.context);
-        this.spinner.start(); // start spinner at beginning
-        /* BOOT */
+        this.spinner.start();
+        /* ================= BOOT ================= */
         {
             const t = startTimer();
             await understandIntentStep.run({ context: this.context });
             logLine("BOOT", "understandIntent", t());
-            // >>> TASK PERSISTENCE ADDITION <<<
-            // create a task immediately after boot
             const db = getDbForRepo();
             const now = new Date().toISOString();
             const userQuery = this.context.initContext?.userQuery ?? "unknown query";
@@ -109,33 +100,35 @@ export class MainAgent {
             `).run(userQuery, now, now);
             this.taskId = result.lastInsertRowid;
             logLine("TASK", `created task id=${this.taskId}"`);
+            logFolderCapsulesSummary(this.context);
         }
-        // =====================================================
-        // INFORMATION ACQUISITION PHASE
-        // Purpose: gather raw information, no interpretation
-        // =====================================================
+        /* ================= FAST-PATH CHECK ================= */
         {
-            const t = startTimer();
-            await preFileSearchCheckStep(this.context);
-            logLine("PRECHECK", "preFileSearch", t());
+            await planResolverStep.run(this.context);
+            const routing = this.context.analysis?.routingDecision;
+            if (routing?.decision === "final-answer" && routing.answer) {
+                logLine("ROUTING", "fastPathHit", undefined, "returning final answer early");
+                return {
+                    query: this.query,
+                    data: { finalAnswer: routing.answer, source: "planResolver" }
+                };
+            }
         }
+        /* ================= INFORMATION ACQUISITION ================= */
         {
-            const t = startTimer();
+            let t = startTimer();
+            await preFileSearchCheckStep(this.context);
+            logLine("PRECHECK", "preFileSearch", t());
+            t = startTimer();
             await infoPlanGen.run(this.context);
             logLine("PLAN", "infoPlanGen", t());
         }
         const infoPlan = this.context.analysis?.planSuggestion?.plan ?? { steps: [] };
-        let stepIO = {
-            query: this.query,
-            context: this.context
-        };
+        let stepIO = { query: this.query };
         for (const step of infoPlan.steps.filter(s => s.groups?.includes("info"))) {
             stepIO = await this.executeStep(step, stepIO);
         }
-        // =====================================================
-        // ANALYSIS PHASE
-        // Purpose: understand what we have and what is being asked
-        // =====================================================
+        /* ================= ANALYSIS PHASE ================= */
         {
             let t = startTimer();
             await selectRelevantSourcesStep.run({ query: this.query, context: this.context });
@@ -158,10 +151,7 @@ export class MainAgent {
             this.resetInitContextForLoop();
             return this.run();
         }
-        // =====================================================
-        // TRANSFORM PHASE
-        // Purpose: produce concrete changes or artifacts
-        // =====================================================
+        /* ================= TRANSFORM PHASE ================= */
         {
             const t = startTimer();
             await transformPlanGenStep.run(this.context);
@@ -171,10 +161,12 @@ export class MainAgent {
         for (const step of transformPlan.steps.filter(s => s.groups?.includes("transform"))) {
             stepIO = await this.executeStep(step, stepIO);
         }
-        // =====================================================
-        // FINALIZE PHASE
-        // Purpose: commit results and respond to the user
-        // =====================================================
+        /*  // ── OPTIONAL DEBUGGING ──
+         debugContext(this.context, {
+             step: "After transform plan generation",
+             note: "Does plan exist?"
+         }); */
+        /* ================= FINALIZE PHASE ================= */
         {
             const t = startTimer();
             await finalPlanGenStep.run(this.context);
@@ -184,9 +176,12 @@ export class MainAgent {
         for (const step of finalPlan.steps.filter(s => s.groups?.includes("finalize"))) {
             stepIO = await this.executeStep(step, stepIO);
         }
-        this.spinner.stop(); // stop spinner at the end
+        this.spinner.stop();
         userOutput("All input/output logs can be found at ~/.scai/input_output.log");
         logLine("RUN", "complete", stopRun());
+        // ───────────── LOG FINAL CONTEXT ─────────────
+        console.log("\n[DEBUG] Final MainAgent context:");
+        console.dir(this.context, { depth: null, colors: true });
         return stepIO;
     }
     /* ───────────── helpers ───────────── */
@@ -196,3 +191,21 @@ export class MainAgent {
         }
     }
 }
+/* ───────────── FOLDER CAPSULES SUMMARY HELPER ───────────── */
+function logFolderCapsulesSummary(context) {
+    if (!context.initContext?.folderCapsules?.length)
+        return;
+    const capsulesSummary = context.initContext.folderCapsules.map(fc => ({
+        path: fc.path,
+        fileCount: fc.stats?.fileCount ?? 0,
+        depth: fc.depth ?? 0,
+        confidence: fc.confidence ?? 0,
+        roles: fc.roles ?? [],
+        concerns: fc.concerns ?? []
+    }));
+    context.analysis ?? (context.analysis = {});
+    context.analysis.folderCapsulesSummary = capsulesSummary;
+    const humanReadable = capsulesSummary.map(fc => `- ${fc.path}: ${fc.fileCount} files, depth ${fc.depth}, confidence ${fc.confidence}`).join("\n");
+    context.analysis.folderCapsulesHuman = humanReadable;
+    logLine("BOOT", "folderCapsulesSummary", undefined, `📂 ${capsulesSummary.length} capsules summarized`);
+}

package/dist/agents/contextReviewStep.js

@@ -2,92 +2,53 @@
 import { generate } from "../lib/generate.js";
 import { logInputOutput } from "../utils/promptLogHelper.js";
 export async function contextReviewStep(context) {
-    if (!context.plan?.targetFiles || context.plan.targetFiles.length === 0) {
-        throw new Error("[contextReviewStep] No targetFiles defined in plan.");
-    }
-    // ------------------------------
-    // Authoritative view: only target files
-    // ------------------------------
-    const authoritativeFiles = (context.workingFiles ?? [])
-        .filter(f => context.plan.targetFiles.includes(f.path))
-        .map((f) => ({
-        path: f.path,
-        hasCode: Boolean(f.code),
-        code: f.code ?? null,
-        summary: f.summary ?? null,
-    }));
-    // ------------------------------
-    // Structural verification: only target files
-    // ------------------------------
-    const structuralProof = context.analysis?.structure
-        ? {
-            fileCount: context.analysis.structure.files.filter(f => context.plan.targetFiles.includes(f.path)).length,
-            files: context.analysis.structure.files
-                .filter(f => context.plan.targetFiles.includes(f.path))
-                .map(f => ({
-                path: f.path,
-                hasCode: Boolean(authoritativeFiles.find(af => af.path === f.path)?.code),
-            })),
-        }
-        : null;
-    // ------------------------------
-    // Include combined architecture analysis
-    // ------------------------------
-    const combinedAnalysis = context.analysis?.combinedAnalysis ?? {};
-    const architectureSummary = combinedAnalysis.architectureSummary ?? "";
-    const hotspots = combinedAnalysis.hotspots ?? [];
+    const analysis = context.analysis;
+    if (!analysis)
+        throw new Error("[contextReviewStep] No analysis state available.");
+    const intent = analysis.intent ?? { intent: "", intentCategory: "", normalizedQuery: "", confidence: 0 };
+    const focus = analysis.focus ?? { relevantFiles: [], missingFiles: [], rationale: "" };
+    const fileAnalysis = analysis.fileAnalysis ?? {};
+    const planDecision = analysis.planSuggestion?.plan ? "planExists" : "needsPlan";
     // ------------------------------
-    // Build prompt
+    // Build prompt using only conclusions from analysis
     // ------------------------------
     const prompt = `
-You are a meta-reasoning agent responsible for determining whether the agent
-has sufficient information to proceed.
+You are a meta-reasoning agent.
+Your job is to determine whether the agent has sufficient information
+to fulfill the user's intent, based on the analysis that has already been performed.
 
-IMPORTANT CONTRACT:
-- Any file listed below with a non-null "code" field MUST be treated as the
-  complete and authoritative source code for that file.
-- Do NOT request file contents again if "code" is present.
+User Intent:
+${JSON.stringify(intent, null, 2)}
 
-User intent:
-${JSON.stringify(context.analysis?.intent ?? {}, null, 2)}
+Relevant Files:
+${JSON.stringify(focus.relevantFiles, null, 2)}
+Missing Files:
+${JSON.stringify(focus.missingFiles, null, 2)}
+Rationale:
+${focus.rationale ?? "No rationale provided."}
 
-Authoritative source files:
-${JSON.stringify(authoritativeFiles, null, 2)}
+File-level Semantic Analysis:
+${JSON.stringify(fileAnalysis, null, 2)}
 
-Structural verification:
-${JSON.stringify(structuralProof, null, 2)}
+Plan Suggestion Status: ${planDecision}
 
-Combined architecture analysis:
-{
-  "architectureSummary": ${JSON.stringify(architectureSummary, null, 2)}
-}
-
-Your task:
-1. Determine whether the available information is sufficient to fulfill the user intent.
-2. If NOT sufficient, explicitly list what is missing.
-3. Output STRICT JSON with the following shape:
+Question:
+Based on the above, can the agent proceed with the user's request?
+Output STRICT JSON with shape:
 
 {
   "decision": "loopAgain" | "stop",
-  "reason": "string",
-  "missing": string[]
+  "reason": "string explaining why or why not",
+  "missing": string[]  // any additional analysis or files needed
 }
-
-Rules:
-- If the intent involves modifying, commenting, refactoring, or analyzing code,
-  and at least one relevant file includes full source code, the context SHOULD
-  be considered sufficient.
-- Do NOT request information that is already present in the authoritative files.
 `.trim();
-    // ------------------------------
-    // Call LLM
-    // ------------------------------
+    logInputOutput("contextReviewStep", "output", prompt);
     const ai = await generate({
         query: context.initContext?.userQuery ?? '',
         content: prompt,
     });
     const text = typeof ai.data === "string" ? ai.data : JSON.stringify(ai.data);
-    logInputOutput("contextReviewHelper", "output", text);
+    logInputOutput("contextReviewStep", "output", text);
     // ------------------------------
     // Parse JSON or fallback
     // ------------------------------

package/dist/agents/planTargetFilesStep.js

@@ -1,9 +1,10 @@
 import { logInputOutput } from "../utils/promptLogHelper.js";
 export const planTargetFilesStep = {
     name: "planTargetFilesStep",
-    description: "Sync files from analysis.focus into plan.targetFiles. Ensures only workingFiles are moved and does not redo intent or risks.",
+    description: "Sync relevant files from analysis.focus into plan.targetFiles, skipping irrelevant files. Ensures only workingFiles are moved and does not redo intent or risks.",
     groups: ["analysis"],
     run: async (input) => {
+        var _a;
         const context = input.context;
         const query = input.query ?? "";
         if (!context) {
@@ -14,8 +15,9 @@ export const planTargetFilesStep = {
             logInputOutput("planTargetFilesStep", "output", output.data);
             return output;
         }
-        // Ensure analysis.focus exists
-        const focusFiles = context.analysis?.focus?.relevantFiles ?? [];
+        const analysis = context.analysis;
+        const focusFiles = analysis?.focus?.relevantFiles ?? [];
+        const fileAnalysisMap = analysis?.fileAnalysis ?? {};
         if (!focusFiles.length) {
             const output = {
                 query,
@@ -26,12 +28,23 @@ export const planTargetFilesStep = {
         }
         // Ensure plan exists
         context.plan || (context.plan = {});
-        // Move relevant files to plan.targetFiles, only if they exist in workingFiles
         const workingFilePaths = new Set(context.workingFiles?.map(f => f.path) ?? []);
         const targetFiles = new Set(context.plan.targetFiles ?? []);
-        focusFiles.forEach(f => {
-            if (workingFilePaths.has(f)) {
-                targetFiles.add(f);
+        const skippedFiles = [];
+        // Ensure discardedFiles array exists
+        if (context.analysis?.focus) {
+            (_a = context.analysis.focus).discardedFiles || (_a.discardedFiles = []);
+        }
+        // Add only non-irrelevant files
+        focusFiles.forEach(filePath => {
+            const analysisEntry = fileAnalysisMap[filePath];
+            if (analysisEntry?.intent === "irrelevant") {
+                skippedFiles.push(filePath);
+                context.analysis.focus.discardedFiles.push(filePath); // add to discardedFiles
+                return;
+            }
+            if (workingFilePaths.has(filePath)) {
+                targetFiles.add(filePath);
             }
         });
         context.plan.targetFiles = Array.from(targetFiles);
@@ -39,7 +52,8 @@ export const planTargetFilesStep = {
             query,
             data: {
                 movedFiles: Array.from(targetFiles),
-                notes: "Focus files successfully moved to plan.targetFiles.",
+                skippedFiles,
+                notes: `Focus files synced to plan.targetFiles. ${skippedFiles.length} irrelevant file(s) skipped and added to discardedFiles.`,
             },
         };
         logInputOutput("planTargetFilesStep", "output", output.data);

package/dist/agents/transformPlanGenStep.js

@@ -31,22 +31,19 @@ or modifications in the system to achieve the intended task.
 Intent / task description:
 ${intentText}
 
-If the intent indicates that this is NOT a coding, refactoring, or inline commenting task,
-then return an empty plan object with an empty "steps" array:
-{ "steps": [] }
-
 Allowed actions (transformation only):
 ${actionsJson}
 
 Task category:
 ${intentCategory}
 
-Folder structure:
-${context.analysis.folderCapsulesHuman ?? ''}
-
 Existing relevant files:
 ${JSON.stringify(context.analysis.focus?.relevantFiles ?? {}, null, 2)}
 
+If the intent indicates that this is NOT a coding, refactoring, or inline commenting task,
+then return an empty plan object with an empty "steps" array:
+{ "steps": [] }
+
 Only perform transformations that are safe based on the existing analysis.
 
 ⚡ Phase guidance:
@@ -74,6 +71,7 @@ Return a strictly valid JSON plan:
             let plan = null;
             // --- Parse strategy ---
             if (cleaned.data && typeof cleaned.data === 'object') {
+                process.stdout.write("\r\x1b[K");
                 console.log('[transformPlanGen][debug] Using parsed JSON from cleanupModule');
                 plan = cleaned.data;
             }

package/dist/index.js

@@ -7,7 +7,7 @@ const shellQuote = require('shell-quote');
 import { createProgram as cmdFactory, withContext } from './commands/factory.js';
 import { runAskCommand } from './commands/AskCmd.js';
 import { setRl } from './commands/ReadlineSingleton.js';
-const program = cmdFactory(); // single Commander instance
+const program = cmdFactory();
 let inShell = false;
 const customCommands = {};
 // =====================================================
@@ -64,10 +64,15 @@ customCommands.quit = customCommands.exit;
 export function registerCommand(name, fn) {
     customCommands[name] = fn;
 }
+// =====================================================
+// SHELL
+// =====================================================
 async function startShell() {
     if (inShell)
         return;
     inShell = true;
+    // Ensure cursor is visible & blinking
+    process.stdout.write('\x1b[?25h');
     const rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout,
@@ -75,70 +80,139 @@ async function startShell() {
         historySize: 200,
     });
     setRl(rl);
+    // Explicit """ multiline
+    let multilineBuffer = null;
+    // Normal buffered input (enter-to-execute)
+    let inputBuffer = [];
+    // --- Buffered paste flush to fix "double Enter" issue
+    let flushHandle = null;
+    const flushInputBuffer = () => {
+        if (flushHandle)
+            return; // already scheduled
+        flushHandle = setImmediate(async () => {
+            flushHandle = null;
+            const fullQuery = inputBuffer.join('\n').trim();
+            inputBuffer = [];
+            if (fullQuery) {
+                await runQuery(fullQuery);
+            }
+            rl.prompt();
+        });
+    };
+    const showCursor = () => {
+        process.stdout.write('\x1b[?25h');
+    };
     rl.prompt();
+    showCursor();
     rl.on('line', async (line) => {
         try {
-            const trimmed = line.trim();
-            if (!trimmed) {
+            showCursor();
+            // =====================================================
+            // Explicit multiline (""" … """)
+            // =====================================================
+            if (multilineBuffer !== null) {
+                if (line.trim() === '"""') {
+                    const fullQuery = multilineBuffer.join('\n');
+                    multilineBuffer = null;
+                    await runQuery(fullQuery);
+                    rl.prompt();
+                    showCursor();
+                    return;
+                }
+                multilineBuffer.push(line);
+                return;
+            }
+            if (line.trim() === '"""') {
+                multilineBuffer = [];
+                console.log('(multiline input — end with """)');
+                return;
+            }
+            // =====================================================
+            // Empty line = EXECUTE buffered input
+            // =====================================================
+            if (line.trim() === '') {
+                const fullQuery = inputBuffer.join('\n').trim();
+                inputBuffer = [];
+                if (fullQuery) {
+                    await runQuery(fullQuery);
+                }
                 rl.prompt();
+                showCursor();
                 return;
             }
-            // --- Shell command
-            if (trimmed.startsWith('!')) {
-                const child = spawn(trimmed.slice(1).trim(), { shell: true, stdio: 'inherit' });
-                child.on('exit', () => rl.prompt());
-                child.on('error', (err) => { console.error('Shell command error:', err); rl.prompt(); });
+            // =====================================================
+            // Shell command
+            // =====================================================
+            if (line.trim().startsWith('!')) {
+                const child = spawn(line.trim().slice(1), {
+                    shell: true,
+                    stdio: 'inherit',
+                });
+                child.on('exit', () => {
+                    rl.prompt();
+                    showCursor();
+                });
                 return;
             }
-            // --- Slash commands
-            if (trimmed.startsWith('/')) {
-                const argvParts = shellQuote.parse(trimmed.slice(1))
-                    .map((tok) => typeof tok === 'object' ? tok.op ?? tok.pattern ?? '' : String(tok))
+            // =====================================================
+            // Slash commands
+            // =====================================================
+            if (line.trim().startsWith('/')) {
+                const argvParts = shellQuote
+                    .parse(line.trim().slice(1))
+                    .map((tok) => typeof tok === 'object'
+                    ? tok.op ?? tok.pattern ?? ''
+                    : String(tok))
                     .filter(Boolean);
                 const cmdName = argvParts[0];
                 if (customCommands[cmdName]) {
                     await customCommands[cmdName]();
                 }
                 else {
-                    try {
-                        await program.parseAsync(argvParts, { from: 'user' });
-                    }
-                    catch (err) {
-                        console.error('Command error:', err instanceof Error ? err.message : err);
-                    }
+                    await program.parseAsync(argvParts, { from: 'user' });
                 }
                 rl.prompt();
+                showCursor();
                 return;
             }
-            // --- Bare input → LLM
-            await withContext(() => runAskCommand(trimmed));
-            rl.prompt();
+            // =====================================================
+            // Otherwise → accumulate input
+            // =====================================================
+            inputBuffer.push(line);
+            flushInputBuffer(); // schedule auto-flush after paste ends
         }
         catch (err) {
             console.error('REPL error:', err instanceof Error ? err.stack : err);
             rl.prompt();
+            showCursor();
         }
     });
-    rl.on('close', () => { console.log('Bye!'); process.exit(0); });
-    process.on('SIGINT', () => { console.log('\nExiting REPL...'); rl.close(); });
+    rl.on('close', () => {
+        showCursor();
+        console.log('Bye!');
+        process.exit(0);
+    });
+    process.on('SIGINT', () => {
+        console.log('\nExiting REPL...');
+        showCursor();
+        rl.close();
+    });
+    process.on('exit', showCursor);
 }
 // ---------------- Main -----------------
 async function main() {
     process.on('unhandledRejection', (reason) => console.error('Unhandled Rejection:', reason));
-    process.on('uncaughtException', (err) => { console.error('Uncaught Exception:', err.stack ?? err); process.exit(1); });
+    process.on('uncaughtException', (err) => {
+        console.error('Uncaught Exception:', err.stack ?? err);
+        process.exit(1);
+    });
     const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
     const args = process.argv.slice(2);
-    // Run REPL if no args OR user typed `scai shell`
-    if (isInteractive && (args.length === 0 || (args.length === 1 && args[0] === 'shell'))) {
+    if (isInteractive &&
+        (args.length === 0 || (args.length === 1 && args[0] === 'shell'))) {
         await startShell();
         return;
     }
-    try {
-        await program.parseAsync(process.argv);
-    }
-    catch (err) {
-        console.error('CLI Error:', err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
+    await program.parseAsync(process.argv);
 }
 main();

package/dist/pipeline/modules/codeTransformModule.js

@@ -2,53 +2,36 @@ import { generate } from "../../lib/generate.js";
 import { cleanupModule } from "./cleanupModule.js";
 import { logInputOutput } from "../../utils/promptLogHelper.js";
 import { splitCodeIntoChunks, countTokens } from "../../utils/splitCodeIntoChunk.js";
-const SINGLE_SHOT_TOKEN_LIMIT = 1800;
-const CHUNK_TOKEN_LIMIT = 1500;
-/**
- * Remove leading/trailing markdown code fences.
- */
+// ───────────── Token limits ─────────────
+const SINGLE_SHOT_TOKEN_LIMIT = 1500; // keep large enough for small files
+const CHUNK_TOKEN_LIMIT = 800; // chunked transformation limit
 function stripCodeFences(text) {
     const lines = text.split("\n");
-    while (lines.length && /^```/.test(lines[0].trim())) {
+    while (lines.length && /^```/.test(lines[0].trim()))
         lines.shift();
-    }
-    while (lines.length && /^```/.test(lines[lines.length - 1].trim())) {
+    while (lines.length && /^```/.test(lines[lines.length - 1].trim()))
         lines.pop();
-    }
     return lines.join("\n");
 }
-/**
- * Heuristic: decide whether chunk output looks unsafe / non-code.
- */
 function isSuspiciousChunkOutput(text, originalChunk) {
     const trimmed = text.trim();
     if (!trimmed)
         return true;
-    // Explanations or meta text
-    if (/here is|transformed|updated code|explanation/i.test(trimmed)) {
+    if (/here is|transformed|updated code|explanation/i.test(trimmed))
         return true;
-    }
-    // JSON-ish output (we do NOT want JSON in chunk mode)
-    if (trimmed.startsWith("{") &&
-        trimmed.endsWith("}")) {
+    if (trimmed.startsWith("{") && trimmed.endsWith("}"))
         return true;
-    }
-    // Extremely short compared to original
-    if (trimmed.length < originalChunk.trim().length * 0.3) {
+    if (trimmed.length < originalChunk.trim().length * 0.3)
         return true;
-    }
     return false;
 }
 export const codeTransformModule = {
     name: "codeTransform",
-    description: "Transforms a single file specified in the current plan step based on user instruction. " +
-        "Outputs full rewritten file content (materialized state).",
+    description: "Transforms a single file specified in the current plan step based on user instruction.",
     groups: ["transform"],
     run: async (input) => {
-        var _a, _b;
-        const query = typeof input.query === "string"
-            ? input.query
-            : String(input.query ?? "");
+        var _a, _b, _c, _d;
+        const query = typeof input.query === "string" ? input.query : String(input.query ?? "");
         const context = input.context;
         if (!context) {
             return { query, data: { files: [], errors: ["No context provided"] } };
@@ -57,26 +40,23 @@ export const codeTransformModule = {
         const step = context.currentStep;
         const targetFile = step?.targetFile;
         if (!targetFile) {
-            return {
-                query,
-                data: { files: [], errors: ["No targetFile specified in current plan step"] },
-            };
+            return { query, data: { files: [], errors: ["No targetFile specified in current plan step"] } };
         }
         const file = workingFiles.find(f => f.path === targetFile);
         if (!file || typeof file.code !== "string") {
-            return {
-                query,
-                data: { files: [], errors: [`Target file not found or missing code: ${targetFile}`] },
-            };
+            return { query, data: { files: [], errors: [`Target file not found or missing code: ${targetFile}`] } };
         }
         const normalizedQuery = context.analysis?.intent?.normalizedQuery ?? query;
         const outputs = [];
         const perFileErrors = [];
         const tokenCount = countTokens(file.code);
-        // =========================================================================
-        // 🔹 PATH 1 — SMALL FILE (JSON, strict)
-        // =========================================================================
+        // ───────────── SMALL FILE ─────────────
         if (tokenCount <= SINGLE_SHOT_TOKEN_LIMIT) {
+            logInputOutput("codeTransform", "output", {
+                file: file.path,
+                tokenCount,
+                message: "Starting small file transformation",
+            });
             const prompt = `
 You are a precise code transformation assistant.
 
@@ -104,105 +84,106 @@ JSON schema:
 }
 `.trim();
             try {
+                logInputOutput("codeTransform", "output", { file: file.path, message: "Sending prompt to LLM" });
                 const llmResponse = await generate({ content: prompt, query });
-                const cleaned = await cleanupModule.run({
-                    query,
-                    content: llmResponse.data,
+                logInputOutput("codeTransform", "output", {
+                    file: file.path,
+                    message: "Received LLM response",
+                    responseSnippet: String(llmResponse.data ?? "").slice(0, 200),
                 });
-                const structured = typeof cleaned.data === "object"
-                    ? cleaned.data
-                    : JSON.parse(cleaned.data ?? "{}");
-                const out = Array.isArray(structured.files)
+                const cleaned = await cleanupModule.run({ query, content: llmResponse.data });
+                const structured = cleaned.data;
+                const out = Array.isArray(structured?.files)
                     ? structured.files.find((f) => f.filePath === file.path)
                     : null;
-                if (!out || typeof out.content !== "string" || !out.content.trim()) {
-                    perFileErrors.push(`Model did not return full content for ${file.path}`);
-                }
-                else {
-                    outputs.push({
-                        filePath: file.path,
-                        content: out.content,
-                        notes: out.notes,
-                    });
+                if (!out || typeof out.content !== "string") {
+                    return { query, data: { files: [], errors: [`Model did not return valid content for ${file.path}`] } };
                 }
+                const finalContent = out.content.trim() ? out.content : file.code;
+                outputs.push({ filePath: file.path, content: finalContent, notes: out.notes });
                 perFileErrors.push(...(structured.errors ?? []));
+                context.execution || (context.execution = {});
+                (_a = context.execution).codeTransformArtifacts || (_a.codeTransformArtifacts = { files: [] });
+                context.execution.codeTransformArtifacts.files = context.execution.codeTransformArtifacts.files.filter(f => f.filePath !== file.path);
+                context.execution.codeTransformArtifacts.files.push({
+                    filePath: file.path,
+                    content: finalContent,
+                    notes: perFileErrors.length ? perFileErrors.join("; ") : undefined,
+                });
+                context.plan || (context.plan = {});
+                (_b = context.plan).touchedFiles || (_b.touchedFiles = []);
+                if (!context.plan.touchedFiles.includes(file.path))
+                    context.plan.touchedFiles.push(file.path);
+                const output = { query, data: { files: outputs, errors: perFileErrors } };
+                logInputOutput("codeTransform", "output", context.execution.codeTransformArtifacts.files);
+                return output;
             }
             catch (err) {
-                return {
-                    query,
-                    data: { files: [], errors: [`LLM call or parsing failed: ${err.message}`] },
-                };
+                return { query, data: { files: [], errors: [`LLM call or cleanup failed: ${err.message}`] } };
             }
         }
-        // =========================================================================
-        // 🔹 PATH 2 — LARGE FILE (chunked, raw text)
-        // =========================================================================
-        else {
-            const chunks = splitCodeIntoChunks(file.code, CHUNK_TOKEN_LIMIT);
-            const transformedChunks = [];
-            for (let i = 0; i < chunks.length; i++) {
-                const chunk = chunks[i];
-                const prompt = `
+        // ───────────── LARGE FILE (chunked) ─────────────
+        const chunks = splitCodeIntoChunks(file.code, CHUNK_TOKEN_LIMIT);
+        const transformedChunks = [];
+        logInputOutput("codeTransform", "output", { file: file.path, chunkCount: chunks.length, message: "Starting chunked transformation" });
+        for (let i = 0; i < chunks.length; i++) {
+            const chunk = chunks[i];
+            // ✅ Add user-facing console log here:
+            process.stdout.write("\r\x1b[K");
+            console.log(` - Processing chunk ${i + 1} of ${chunks.length} for ${file.path}...`);
+            logInputOutput("codeTransform", "output", {
+                file: file.path,
+                chunkIndex: i + 1,
+                chunkLength: chunk.length,
+                message: "Processing chunk",
+            });
+            const prompt = `
 You are a precise code transformation assistant.
 
 User instruction (normalized):
 ${normalizedQuery}
 
-You are given ONE CHUNK of a larger file.
-
 Rules:
 - Apply the instruction ONLY if relevant to this chunk.
 - If no change is needed, return the chunk UNCHANGED.
-- Do NOT add or remove unrelated code.
-- Do NOT reference other chunks.
-- Return ONLY code. No JSON. No explanations. No markdown fences.
+- Return ONLY code.
 
 FILE: ${file.path}
 CHUNK ${i + 1} / ${chunks.length}
 ---
 ${chunk}
 `.trim();
-                try {
-                    logInputOutput("chunks", "output", chunk);
-                    const llmResponse = await generate({ content: prompt, query });
-                    const raw = typeof llmResponse.data === "string"
-                        ? llmResponse.data
-                        : String(llmResponse.data ?? "");
-                    const stripped = stripCodeFences(raw);
-                    if (isSuspiciousChunkOutput(stripped, chunk)) {
-                        transformedChunks.push(chunk);
-                        perFileErrors.push(`Chunk ${i + 1} suspicious output; original preserved.`);
-                    }
-                    else {
-                        transformedChunks.push(stripped);
-                    }
-                }
-                catch (err) {
+            try {
+                const llmResponse = await generate({ content: prompt, query });
+                const raw = String(llmResponse.data ?? "");
+                const stripped = stripCodeFences(raw);
+                if (isSuspiciousChunkOutput(stripped, chunk)) {
                     transformedChunks.push(chunk);
-                    perFileErrors.push(`Chunk ${i + 1} failed; original preserved. Error: ${err.message}`);
+                    perFileErrors.push(`Chunk ${i + 1} suspicious; original preserved.`);
+                    logInputOutput("codeTransform", "output", { file: file.path, chunkIndex: i + 1, message: "Suspicious output, original chunk preserved" });
+                }
+                else {
+                    transformedChunks.push(stripped);
+                    logInputOutput("codeTransform", "output", { file: file.path, chunkIndex: i + 1, message: "Chunk transformed successfully" });
                 }
             }
-            outputs.push({
-                filePath: file.path,
-                content: transformedChunks.join("\n"),
-            });
+            catch (err) {
+                transformedChunks.push(chunk);
+                perFileErrors.push(`Chunk ${i + 1} failed; original preserved. Error: ${err.message}`);
+                logInputOutput("codeTransform", "output", { file: file.path, chunkIndex: i + 1, error: err.message, message: "Chunk transformation failed, original preserved" });
+            }
         }
-        // =========================================================================
-        // 🔹 Persist execution artifacts
-        // =========================================================================
+        logInputOutput("codeTransform", "output", { file: file.path, message: "Finished all chunks", totalChunks: chunks.length });
+        outputs.push({ filePath: file.path, content: transformedChunks.join("\n") });
         context.execution || (context.execution = {});
-        (_a = context.execution).codeTransformArtifacts || (_a.codeTransformArtifacts = { files: [] });
+        (_c = context.execution).codeTransformArtifacts || (_c.codeTransformArtifacts = { files: [] });
         context.execution.codeTransformArtifacts.files.push(...outputs);
         context.plan || (context.plan = {});
-        (_b = context.plan).touchedFiles || (_b.touchedFiles = []);
-        if (!context.plan.touchedFiles.includes(file.path)) {
+        (_d = context.plan).touchedFiles || (_d.touchedFiles = []);
+        if (!context.plan.touchedFiles.includes(file.path))
             context.plan.touchedFiles.push(file.path);
-        }
-        const output = {
-            query,
-            data: { files: outputs, errors: perFileErrors },
-        };
-        logInputOutput("codeTransform", "output", output.data);
+        const output = { query, data: { files: outputs, errors: perFileErrors } };
+        logInputOutput("codeTransform", "output", context.execution.codeTransformArtifacts.files);
         return output;
     },
 };

package/dist/utils/splitCodeIntoChunk.js

@@ -1,6 +1,8 @@
 import { encode } from 'gpt-3-encoder';
-export function splitCodeIntoChunks(text, softLimit = 1500, hardLimitMultiplier = 2) {
-    const hardLimit = softLimit * hardLimitMultiplier;
+export function splitCodeIntoChunks(text, softLimit = 800, // reduced from 1500
+hardLimitMultiplier = 1.5 // reduced from 2, so hard limit ~1200
+) {
+    const hardLimit = Math.floor(softLimit * hardLimitMultiplier);
     const lines = text.split('\n');
     const chunks = [];
     let currentChunkLines = [];
@@ -59,15 +61,13 @@ export function splitCodeIntoChunks(text, softLimit = 1500, hardLimitMultiplier
                 globalBraceDepth = Math.max(0, globalBraceDepth - 1);
                 if (inFunction) {
                     functionBraceDepth = Math.max(0, functionBraceDepth - 1);
-                    if (functionBraceDepth === 0) {
+                    if (functionBraceDepth === 0)
                         justClosedFunction = true;
-                    }
                 }
                 if (inTryChain) {
                     tryBraceDepth = Math.max(0, tryBraceDepth - 1);
-                    if (tryBraceDepth === 0) {
+                    if (tryBraceDepth === 0)
                         justClosedTryBlock = true;
-                    }
                 }
             }
             else if (char === '(') {
@@ -87,7 +87,6 @@ export function splitCodeIntoChunks(text, softLimit = 1500, hardLimitMultiplier
             inFunction = false;
         if (justClosedTryBlock) {
             inTryBlock = false;
-            // Only close the chain if we've already seen a handler
             if (tryChainHasHandler) {
                 inTryChain = false;
                 tryChainHasHandler = false;

package/package.json

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