scai 0.1.103 → 0.1.104

package/dist/CHANGELOG.md

@@ -146,4 +146,8 @@ Type handling with the module pipeline
 
 • 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
+• Update CLI config file to use codellama:13b model and 4096 context length
+
+## 2025-08-30
+
+* Add new workflow management functionality to handle file writes.

package/dist/commands/SwitchCmd.js

@@ -1,7 +1,7 @@
 // File: src/commands/switch.ts
 import readline from 'readline';
 import { Config, writeConfig } from '../config.js';
-import { getRepoKeyForPath } from '../utils/normalizePath.js';
+import { getRepoKeyForPath } from '../utils/contentUtils.js';
 import chalk from 'chalk';
 export function runSwitchCommand(inputPathOrKey) {
     const config = Config.getRaw();

package/dist/config.js

@@ -2,7 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import { CONFIG_PATH, SCAI_HOME, SCAI_REPOS } from './constants.js';
 import { getDbForRepo } from './db/client.js';
-import { normalizePath } from './utils/normalizePath.js';
+import { normalizePath } from './utils/contentUtils.js';
 import chalk from 'chalk';
 import { getHashedRepoKey } from './utils/repoKey.js';
 const defaultConfig = {

package/dist/context.js

@@ -1,10 +1,12 @@
 // context.ts
-import { readConfig, writeConfig } from "./config.js";
-import { normalizePath } from "./utils/normalizePath.js";
+import { readConfig, writeConfig, Config } from "./config.js";
+import { normalizePath } from "./utils/contentUtils.js";
 import { getHashedRepoKey } from "./utils/repoKey.js";
 import { getDbForRepo, getDbPathForRepo } from "./db/client.js";
 import fs from "fs";
 import chalk from "chalk";
+import { generate } from "./lib/generate.js"; // 👈 use your existing generate wrapper
+import { startModelProcess } from "./utils/checkModel.js";
 export async function updateContext() {
     const cwd = normalizePath(process.cwd());
     const cfg = readConfig();
@@ -54,6 +56,17 @@ export async function updateContext() {
     else if (isNewRepo || activeRepoChanged) {
         console.log(chalk.green("✅ Database present"));
     }
+    // ✅ NEW: Ensure model is available
+    if (ok) {
+        const modelReady = await ensureModelReady();
+        if (modelReady) {
+            console.log(chalk.green("✅ Model ready"));
+        }
+        else {
+            console.log(chalk.red("❌ Model not available"));
+            ok = false;
+        }
+    }
     // Final context status
     if (ok) {
         console.log(chalk.bold.green("\n✅ Context OK\n"));
@@ -63,3 +76,15 @@ export async function updateContext() {
     }
     return ok;
 }
+async function ensureModelReady() {
+    try {
+        // simple "ping" prompt that costs almost nothing
+        const res = await generate({ content: "ping" }, Config.getModel());
+        return Boolean(res?.content);
+    }
+    catch {
+        console.log(chalk.yellow("⚡ Model not responding. Attempting to start..."));
+        await startModelProcess();
+        return false;
+    }
+}

package/dist/index.js

@@ -26,13 +26,14 @@ import { runInteractiveSwitch } from "./commands/SwitchCmd.js";
 import { execSync } from "child_process";
 import { fileURLToPath } from "url";
 import { dirname, resolve } from "path";
-import { handleAgentRun } from './agentManager.js';
+import { handleAgentRun } from './workflowManager.js';
 import { addCommentsModule } from './pipeline/modules/commentModule.js';
 import { generateTestsModule } from './pipeline/modules/generateTestsModule.js';
 import { preserveCodeModule } from './pipeline/modules/preserveCodeModule.js';
 import { runInteractiveDelete } from './commands/DeleteIndex.js';
 import { resolveTargetsToFiles } from './utils/resolveTargetsToFiles.js';
 import { updateContext } from './context.js';
+import { cleanGeneratedTestsModule } from './pipeline/modules/cleanGeneratedTestsModule.js';
 // 🎛️ CLI Setup
 const cmd = new Command('scai')
     .version(version)
@@ -149,12 +150,14 @@ gen
     });
 });
 gen
-    .command('testgen <file>')
-    .description('Generate tests for the given file')
-    .option('-a, --apply', 'Apply the output to the original file')
-    .action(async (file) => {
+    .command("test <targets...>")
+    .description("Generate tests for the given file(s) or folder(s)")
+    .action(async (targets, options) => {
     await withContext(async () => {
-        handleAgentRun(file, [generateTestsModule]);
+        const files = await resolveTargetsToFiles(targets);
+        for (const file of files) {
+            await handleAgentRun(file, [generateTestsModule, cleanGeneratedTestsModule]);
+        }
     });
 });
 // ⚙️ Group: Configuration settings

package/dist/pipeline/modules/cleanGeneratedTestsModule.js

@@ -0,0 +1,21 @@
+import { normalizeText, stripMarkdownFences, isCodeLike } from "../../utils/contentUtils.js";
+export const cleanGeneratedTestsModule = {
+    name: "cleanGeneratedTestsModule",
+    description: "Removes markdown fences, prose, and explanations from generated test output, leaving only code",
+    async run(input) {
+        const { content, filepath } = input;
+        // normalize + strip markdown
+        const normalized = normalizeText(content);
+        const stripped = stripMarkdownFences(normalized);
+        // filter non-code lines
+        const lines = stripped.split("\n");
+        const codeLines = lines.filter(line => isCodeLike(line));
+        const cleanedCode = codeLines.join("\n");
+        return {
+            originalContent: content,
+            content: cleanedCode, // cleaned code for pipeline
+            filepath, // original file path
+            mode: "overwrite", // indicates overwrite existing file
+        };
+    }
+};

package/dist/pipeline/modules/commentModule.js

@@ -59,6 +59,9 @@ ${input.content}
 `.trim();
         const response = await generate({ content: prompt }, model);
         const contentToReturn = (response.content && response.content !== 'NO UPDATE') ? response.content : input.content;
-        return { content: contentToReturn };
+        return {
+            content: contentToReturn,
+            mode: 'overwrite', // <-- declares that the original file should be overwritten
+        };
     },
 };

package/dist/pipeline/modules/generateTestsModule.js

@@ -1,4 +1,3 @@
-import fs from 'fs/promises';
 import path from 'path';
 import { generate } from '../../lib/generate.js';
 import { detectFileType } from '../../fileRules/detectFileType.js';
@@ -25,14 +24,18 @@ export const generateTestsModule = {
       --- CODE START ---
       ${content}
       --- CODE END ---
-      `.trim();
+    `.trim();
         const response = await generate({ content: prompt }, model);
         if (!response)
             throw new Error('⚠️ No test code returned from model');
         const { dir, name } = path.parse(filepath);
         const testPath = path.join(dir, `${name}.test.ts`);
-        await fs.writeFile(testPath, response.content, 'utf-8');
-        console.log(`✅ Test file saved to: ${testPath}`);
-        return { content, filepath }; // unchanged input
+        return {
+            originalContent: content,
+            content: response.content, // the test code
+            filepath, // original file path
+            newFilepath: testPath,
+            mode: "newFile" // where it *should* be written
+        };
     }
 };

package/dist/pipeline/modules/preserveCodeModule.js

@@ -144,6 +144,10 @@ export const preserveCodeModule = {
             const colored = type === "code" ? chalk.green(line) : chalk.yellow(line);
             console.log(`${i + 1}: ${colored} ${chalk.gray(`[${type}]`)}`);
         });
-        return { content: fixedLines.join("\n"), filepath };
+        return {
+            content: fixedLines.join("\n"),
+            filepath,
+            mode: "overwrite"
+        };
     }
 };

package/dist/pipeline/registry/moduleRegistry.js

@@ -4,6 +4,8 @@ import { summaryModule } from '../modules/summaryModule.js';
 import { generateTestsModule } from '../modules/generateTestsModule.js';
 import { commitSuggesterModule } from '../modules/commitSuggesterModule.js';
 import { changelogModule } from '../modules/changeLogModule.js';
+import { cleanGeneratedTestsModule } from '../modules/cleanGeneratedTestsModule.js';
+import { preserveCodeModule } from '../modules/preserveCodeModule.js';
 // Add more as needed...
 const builtInModules = {
     comments: addCommentsModule,
@@ -12,6 +14,8 @@ const builtInModules = {
     tests: generateTestsModule,
     suggest: commitSuggesterModule,
     changelog: changelogModule,
+    cleantTests: cleanGeneratedTestsModule,
+    cleanComments: preserveCodeModule
 };
 export function getModuleByName(name) {
     return builtInModules[name];

package/dist/utils/checkModel.js

@@ -0,0 +1,30 @@
+import { spawn } from "child_process";
+let modelProcess = null;
+async function isModelRunning() {
+    try {
+        const res = await fetch("http://localhost:11434/health"); // whatever endpoint your model exposes
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+export async function startModelProcess() {
+    if (await isModelRunning()) {
+        console.log("✅ Model already running");
+        return;
+    }
+    console.log("🚀 Starting model process...");
+    modelProcess = spawn("ollama", ["serve"], {
+        stdio: "inherit",
+    });
+    // Poll until the model is ready
+    for (let i = 0; i < 30; i++) {
+        if (await isModelRunning()) {
+            console.log("✅ Model is now running");
+            return;
+        }
+        await new Promise((res) => setTimeout(res, 1000));
+    }
+    throw new Error("❌ Model failed to start in time");
+}

package/dist/utils/contentUtils.js

@@ -0,0 +1,49 @@
+import os from 'os';
+import path from "path";
+/**
+ * Normalizes a path string for loose, fuzzy matching:
+ * - Lowercases
+ * - Removes slashes and backslashes
+ * - Removes whitespace
+ */
+export function normalizePathForLooseMatch(p) {
+    return p.toLowerCase().replace(/[\\/]/g, '').replace(/\s+/g, '');
+}
+// Helper to normalize and resolve paths to a consistent format (forward slashes)
+export function normalizePath(p) {
+    if (p.startsWith('~')) {
+        p = path.join(os.homedir(), p.slice(1));
+    }
+    return path.resolve(p).replace(/\\/g, '/');
+}
+export function getRepoKeyForPath(pathToMatch, config) {
+    const norm = normalizePath(pathToMatch);
+    return Object.entries(config.repos).find(([, val]) => normalizePath(val.indexDir) === norm)?.[0] || null;
+}
+export function normalizeText(txt) {
+    return txt.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+export function stripMarkdownFences(txt) {
+    return txt
+        .replace(/```[\w-]*\s*/g, "") // ``` or ```java
+        .replace(/```/g, ""); // closing ```
+}
+// Very naive classifier: decide if a line is "code-like"
+export function isCodeLike(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return false;
+    // obvious markdown / prose markers
+    if (/^(This|Here is|Note)\b/.test(trimmed))
+        return false;
+    if (/^\d+\./.test(trimmed))
+        return false; // bullet list
+    if (/^[-*] /.test(trimmed))
+        return false; // list
+    // allow imports, class, functions, braces, annotations, etc.
+    if (/^(import|export|public|private|protected|class|function|@Test|@Before)/.test(trimmed))
+        return true;
+    if (/[;{}()=]/.test(trimmed))
+        return true;
+    return false;
+}

package/dist/utils/repoKey.js

@@ -1,6 +1,6 @@
 import crypto from 'crypto';
 import path from 'path';
-import { normalizePath } from './normalizePath.js';
+import { normalizePath } from './contentUtils.js';
 /**
  * Generate a stable unique key for a repo path.
  * Uses the basename plus a short hash of the full path.

package/dist/workflowManager.js

@@ -0,0 +1,89 @@
+// agentManager.ts
+import fs from 'fs/promises';
+import chalk from 'chalk';
+import { runModulePipeline } from './pipeline/runModulePipeline.js';
+import { countTokens, splitCodeIntoChunks } from './utils/splitCodeIntoChunk.js';
+import { normalizePath } from './utils/contentUtils.js';
+export async function handleAgentRun(filepath, modules) {
+    try {
+        filepath = normalizePath(filepath);
+        let fileContent = await fs.readFile(filepath, 'utf-8');
+        // Immutable baseline for this file (stays until file changes)
+        const maxTokens = 1500;
+        const baseChunks = splitCodeIntoChunks(fileContent, maxTokens);
+        // Working chunks that flow through modules; stays index-aligned with baseChunks
+        let workingChunks = [...baseChunks];
+        for (const mod of modules) {
+            console.log(chalk.cyan(`\n⚙️ Running module: ${mod.name}`));
+            console.log(chalk.blue(`🧮 Tokens:`), chalk.yellow(countTokens(fileContent).toString()));
+            console.log(chalk.magenta(`📦 Chunks: ${workingChunks.length}`));
+            const processed = [];
+            let mode;
+            let newFilepath;
+            for (let i = 0; i < workingChunks.length; i++) {
+                const input = {
+                    originalContent: baseChunks[i], // immutable baseline for this file
+                    content: workingChunks[i], // current state for this slice
+                    filepath,
+                    chunkIndex: i,
+                    chunkCount: workingChunks.length,
+                };
+                const out = await runModulePipeline([mod], input);
+                if (!out.content?.trim()) {
+                    throw new Error(`⚠️ Empty result on chunk ${i + 1}`);
+                }
+                processed.push(out.content);
+                // Capture mode/path (should be consistent across chunks)
+                if (out.mode)
+                    mode = out.mode;
+                if (out.newFilepath)
+                    newFilepath = out.newFilepath;
+            }
+            const finalOutput = processed.join('\n\n');
+            // Apply output mode
+            switch (mode ?? 'overwrite') {
+                case 'overwrite':
+                    await fs.writeFile(filepath, finalOutput, 'utf-8');
+                    console.log(chalk.green(`✅ Overwritten: ${filepath}`));
+                    // keep baseChunks (baseline stays the same), keep alignment: do NOT re-chunk
+                    workingChunks = processed;
+                    fileContent = finalOutput;
+                    break;
+                case 'append':
+                    await fs.appendFile(filepath, finalOutput, 'utf-8');
+                    console.log(chalk.green(`✅ Appended: ${filepath}`));
+                    // appended file content diverges; keep alignment by using processed as new working
+                    workingChunks = processed;
+                    fileContent += finalOutput;
+                    break;
+                case 'newFile':
+                    if (!newFilepath)
+                        throw new Error(`newFile mode requires newFilepath`);
+                    await fs.writeFile(newFilepath, finalOutput, 'utf-8');
+                    console.log(chalk.green(`✅ New file: ${newFilepath}`));
+                    // File context changes → reset baseline and working to the new file
+                    filepath = newFilepath;
+                    fileContent = finalOutput;
+                    const reset = splitCodeIntoChunks(fileContent, maxTokens);
+                    // new baseline for the new file (e.g., generated tests before cleaning)
+                    for (let i = 0; i < reset.length; i++)
+                        ; // (no-op; just clarity)
+                    // Replace both arrays to keep them in sync for subsequent modules
+                    workingChunks = reset;
+                    // Important: also reset baseChunks to this new file’s content so the next module
+                    // (e.g., cleaner) sees the *generated tests* as its originalContent baseline.
+                    baseChunks.length = 0;
+                    baseChunks.push(...reset);
+                    break;
+                default:
+                    console.log(chalk.yellow(`⚠️ Unknown mode; skipping write`));
+                    // still move pipeline forward with processed
+                    workingChunks = processed;
+                    fileContent = finalOutput;
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('❌ Error in agent run:'), err instanceof Error ? err.message : err);
+    }
+}

package/package.json

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

package/dist/agentManager.js

@@ -1,47 +0,0 @@
-import fs from 'fs/promises';
-import chalk from 'chalk';
-import { runModulePipeline } from './pipeline/runModulePipeline.js';
-import { normalizePath } from './utils/normalizePath.js';
-import { readConfig } from './config.js';
-import { countTokens, splitCodeIntoChunks } from './utils/splitCodeIntoChunk.js';
-export async function handleAgentRun(filepath, modules) {
-    try {
-        filepath = normalizePath(filepath);
-        const content = await fs.readFile(filepath, 'utf-8');
-        const totalTokens = countTokens(content);
-        console.log(chalk.blue(`🧮 Total tokens in file:`), chalk.yellow(totalTokens.toString()));
-        const config = readConfig();
-        const maxTokens = 1500;
-        const chunks = splitCodeIntoChunks(content, maxTokens);
-        console.log(chalk.magenta(`📦 Split into ${chunks.length} chunks`));
-        const processedChunks = [];
-        for (const [i, chunk] of chunks.entries()) {
-            const chunkTokens = countTokens(chunk);
-            if (i === 0) {
-                console.log(chalk.cyan(`🔍 Processing ${chunks.length} chunks of file:`), chalk.white(filepath));
-            }
-            console.log(chalk.gray(`   - Chunk ${i + 1} tokens:`), chalk.yellow(chunkTokens.toString()));
-            const chunkInput = {
-                originalContent: chunk,
-                content: chunk,
-                filepath,
-                chunkIndex: i,
-                chunkCount: chunks.length,
-            };
-            const response = await runModulePipeline(modules, chunkInput);
-            if (!response.content.trim()) {
-                throw new Error(`⚠️ Model returned empty result on chunk ${i + 1}`);
-            }
-            processedChunks.push(response.content);
-            //console.log(chalk.green(`✅ Finished chunk ${i + 1}/${chunks.length}`));
-        }
-        // Join all chunk outputs into one string
-        const finalOutput = processedChunks.join('\n\n');
-        // Overwrite original file here:
-        await fs.writeFile(filepath, finalOutput, 'utf-8');
-        console.log(chalk.green(`✅ Original file overwritten: ${filepath}`));
-    }
-    catch (err) {
-        console.error(chalk.red('❌ Error in agent run:'), err instanceof Error ? err.message : err);
-    }
-}

package/dist/utils/normalizePath.js

@@ -1,23 +0,0 @@
-// src/utils/normalizePath.ts
-import os from 'os';
-import path from "path";
-/**
- * Normalizes a path string for loose, fuzzy matching:
- * - Lowercases
- * - Removes slashes and backslashes
- * - Removes whitespace
- */
-export function normalizePathForLooseMatch(p) {
-    return p.toLowerCase().replace(/[\\/]/g, '').replace(/\s+/g, '');
-}
-// Helper to normalize and resolve paths to a consistent format (forward slashes)
-export function normalizePath(p) {
-    if (p.startsWith('~')) {
-        p = path.join(os.homedir(), p.slice(1));
-    }
-    return path.resolve(p).replace(/\\/g, '/');
-}
-export function getRepoKeyForPath(pathToMatch, config) {
-    const norm = normalizePath(pathToMatch);
-    return Object.entries(config.repos).find(([, val]) => normalizePath(val.indexDir) === norm)?.[0] || null;
-}