scai 0.1.104 → 0.1.106

package/dist/CHANGELOG.md

@@ -150,4 +150,16 @@ Type handling with the module pipeline
 
 ## 2025-08-30
 
-* Add new workflow management functionality to handle file writes.
+* Add new workflow management functionality to handle file writes.
+
+## 2025-08-31
+
+• Introduce Agent class with minimal implementation
+• Improve test-module's filepath handling and variable naming
+• Rename workflowManager.ts to agent/workflowManager.ts
+• Improved formatting of agent run summary output
+
+## 2025-08-31
+
+• Update Spinner class to correctly display text and frames
+• Update CLI help to reflect new agent workflow examples.

package/dist/agent/agentManager.js

@@ -0,0 +1,27 @@
+// src/agent/agentManager.ts
+import chalk from "chalk";
+import fs from "fs/promises";
+import { resolveModuleOrder } from "../pipeline/registry/moduleRegistry.js";
+import { handleAgentRun } from "./workflowManager.js";
+// Minimal agent: resolves modules (with before/after dependencies) and delegates to handleAgentRun
+export class Agent {
+    constructor(goals) {
+        // Trim goal names to avoid whitespace issues
+        this.goals = goals.map((g) => g.trim());
+    }
+    resolveModules(goals) {
+        // Use the registry helper to get the correct order
+        return resolveModuleOrder(goals);
+    }
+    async execute(filepath) {
+        console.log(chalk.cyan(`🤖 Agent starting on: ${filepath}`));
+        // Resolve modules (with before/after dependencies)
+        const modules = this.resolveModules(this.goals);
+        console.log(chalk.green("📋 Modules to run:"), modules.map((m) => m.name).join(" → "));
+        // Read file content (optional, could be used by modules in workflow)
+        await fs.readFile(filepath, "utf-8");
+        // Delegate everything to handleAgentRun (like CLI commands do)
+        await handleAgentRun(filepath, modules);
+        console.log(chalk.green("✅ Agent finished!"));
+    }
+}

package/dist/{workflowManager.js → agent/workflowManager.js}

@@ -1,9 +1,10 @@
 // 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';
+import { runModulePipeline } from '../pipeline/runModulePipeline.js';
+import { countTokens, splitCodeIntoChunks } from '../utils/splitCodeIntoChunk.js';
+import { normalizePath } from '../utils/contentUtils.js';
+// basically handles all input (chunk if large), and writing of output (overwrite, append, new file)
 export async function handleAgentRun(filepath, modules) {
     try {
         filepath = normalizePath(filepath);

package/dist/context.js

@@ -1,12 +1,10 @@
 // context.ts
-import { readConfig, writeConfig, Config } from "./config.js";
+import { readConfig, writeConfig } 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();
@@ -56,17 +54,6 @@ 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"));
@@ -76,15 +63,3 @@ 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

@@ -8,7 +8,6 @@ import { suggestCommitMessage } from "./commands/CommitSuggesterCmd.js";
 import { bootstrap } from './modelSetup.js';
 import { summarizeFile } from "./commands/SummaryCmd.js";
 import { handleStandaloneChangelogUpdate } from './commands/ChangeLogUpdateCmd.js';
-import { runModulePipelineFromCLI } from './commands/ModulePipelineCmd.js';
 import { runIndexCommand } from './commands/IndexCmd.js';
 import { resetDatabase } from './commands/ResetDbCmd.js';
 import { runFindCommand } from './commands/FindCmd.js';
@@ -26,14 +25,10 @@ import { runInteractiveSwitch } from "./commands/SwitchCmd.js";
 import { execSync } from "child_process";
 import { fileURLToPath } from "url";
 import { dirname, resolve } from "path";
-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';
+import { Agent } from './agent/agentManager.js';
 // 🎛️ CLI Setup
 const cmd = new Command('scai')
     .version(version)
@@ -47,6 +42,38 @@ cmd
     await bootstrap();
     console.log('✅ Model initialization completed!');
 });
+// 🔧 Group: Agent-related commands
+const agent = cmd
+    .command('agent')
+    .description(`Run an agent workflow. Example available tools:\n` +
+    `  - summary\n` +
+    `  - comments\n` +
+    `  - tests\n\n` +
+    `Example usage:\n` +
+    `  $ scai agent run comments tests -f path/to/myfile\n` +
+    `  This will run the agent with the goals: comments → tests\n`);
+// Run workflow subcommand
+const runCmd = agent
+    .command('run <goals...>')
+    .description('Run an agent workflow with a list of goals')
+    .option('-f, --file <filepath>', 'File to process', 'example.txt')
+    .action(async (cmdGoals, cmd) => {
+    await withContext(async () => {
+        const goals = cmdGoals;
+        const file = cmd.file;
+        console.log('Agent will execute:', goals.join(' → '));
+        console.log('On file:', file);
+        const agentInstance = new Agent(goals);
+        await agentInstance.execute(file);
+    });
+});
+// Optional: show example modules on --help
+runCmd.on('--help', () => {
+    console.log('\nExample tools:');
+    console.log('  - summary');
+    console.log('  - comments');
+    console.log('  - tests');
+});
 // 🔧 Group: Git-related commands
 const git = cmd.command('git').description('Git utilities');
 git
@@ -126,10 +153,22 @@ gen
     .description("Write comments for the given file(s) or folder(s)")
     .action(async (targets) => {
     await withContext(async () => {
-        // Remove the file type filter to allow any file
         const files = await resolveTargetsToFiles(targets);
         for (const file of files) {
-            await handleAgentRun(file, [addCommentsModule, preserveCodeModule]);
+            const agent = new Agent(["comments"]); // goals: "comments"
+            await agent.execute(file); // run on the file
+        }
+    });
+});
+gen
+    .command("test <targets...>")
+    .description("Generate tests for the given file(s) or folder(s)")
+    .action(async (targets) => {
+    await withContext(async () => {
+        const files = await resolveTargetsToFiles(targets);
+        for (const file of files) {
+            const agent = new Agent(["tests"]); // goals: "tests"
+            await agent.execute(file);
         }
     });
 });
@@ -149,17 +188,6 @@ gen
         summarizeFile(file);
     });
 });
-gen
-    .command("test <targets...>")
-    .description("Generate tests for the given file(s) or folder(s)")
-    .action(async (targets, options) => {
-    await withContext(async () => {
-        const files = await resolveTargetsToFiles(targets);
-        for (const file of files) {
-            await handleAgentRun(file, [generateTestsModule, cleanGeneratedTestsModule]);
-        }
-    });
-});
 // ⚙️ Group: Configuration settings
 const config = cmd.command('config').description('Manage SCAI configuration');
 config
@@ -301,18 +329,6 @@ cmd
     const fullQuery = questionParts?.join(' ');
     await runAskCommand(fullQuery);
 }));
-cmd
-    .command('pipe')
-    .description('Run a module pipeline on a given file')
-    .argument('<file>', 'Target file')
-    .option('-m, --modules <modules>', 'Comma-separated list of modules to run (e.g., comments,cleanup,summary)')
-    .action((file, options) => {
-    if (!options.modules) {
-        console.error('❌ You must specify modules with -m or --modules');
-        process.exit(1);
-    }
-    runModulePipelineFromCLI(file, options);
-});
 cmd.addHelpText('after', `
 🚨 Alpha Features:
   - The "index", "daemon", "stop-daemon", "reset-db" commands are considered alpha features.

package/dist/lib/generate.js

@@ -1,35 +1,40 @@
 // File: lib/generate.ts
 import { Spinner } from './spinner.js';
 import { readConfig } from '../config.js';
+import { startModelProcess } from '../utils/checkModel.js';
 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}). `);
+        console.warn(`⚠️ Warning: Input prompt length (${prompt.length}) exceeds model context length (${contextLength}).`);
     }
     const spinner = new Spinner(`🧠 Thinking with ${model}...`);
     spinner.start();
     try {
-        const res = await fetch('http://localhost:11434/api/generate', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                model,
-                prompt, // use truncated prompt here
-                stream: false,
-            }),
-        });
-        const data = await res.json();
-        spinner.succeed('Model response received.');
-        process.stdout.write('\n');
-        return {
-            content: data.response?.trim() ?? '',
-            filepath: input.filepath,
-        };
+        return await doGenerate(prompt, model, spinner, false);
     }
     catch (err) {
-        spinner.fail('Model request failed.');
+        spinner.fail('Model request failed. Attempting to start model...');
         process.stdout.write('\n');
-        throw err;
+        await startModelProcess();
+        spinner.update(`🧠 Retrying with ${model}...`);
+        return await doGenerate(prompt, model, spinner, true); // retry once
     }
 }
+async function doGenerate(prompt, model, spinner, retrying) {
+    const res = await fetch('http://localhost:11434/api/generate', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            model,
+            prompt,
+            stream: false,
+        }),
+    });
+    const data = await res.json();
+    spinner.succeed(retrying ? 'Model response received after restart.' : 'Model response received.');
+    process.stdout.write('\n');
+    return {
+        content: data.response?.trim() ?? '',
+    };
+}

package/dist/lib/spinner.js

@@ -1,4 +1,3 @@
-// lib/spinner.ts
 export class Spinner {
     constructor(message) {
         this.frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
@@ -8,18 +7,25 @@ export class Spinner {
     }
     start() {
         process.stdout.write('\x1b[?25l'); // hide cursor
+        process.stdout.write(` ${this.text}`); // print text once
         this.interval = setInterval(() => {
-            const frame = this.frames[this.i = ++this.i % this.frames.length];
-            process.stdout.write(`\r${frame} ${this.text} `);
+            process.stdout.write('\r'); // return to start of line
+            process.stdout.write(`${this.frames[this.i]} ${this.text}`);
+            this.i = (this.i + 1) % this.frames.length;
         }, 80);
     }
+    update(text) {
+        this.text = text;
+    }
     succeed(msg) {
         this.stop();
-        process.stdout.write(`\r✅ ${msg}\n`);
+        process.stdout.write('\r'); // go to start
+        console.log(`✅ ${msg}`);
     }
     fail(msg) {
         this.stop();
-        process.stdout.write(`\r❌ ${msg}\n`);
+        process.stdout.write('\r'); // go to start
+        console.log(`❌ ${msg}`);
     }
     stop() {
         if (this.interval) {

package/dist/pipeline/modules/cleanGeneratedTestsModule.js

@@ -9,7 +9,8 @@ export const cleanGeneratedTestsModule = {
         const stripped = stripMarkdownFences(normalized);
         // filter non-code lines
         const lines = stripped.split("\n");
-        const codeLines = lines.filter(line => isCodeLike(line));
+        // filter non-code lines, but keep blank ones
+        const codeLines = lines.filter(line => line.trim() === "" || isCodeLike(line));
         const cleanedCode = codeLines.join("\n");
         return {
             originalContent: content,

package/dist/pipeline/modules/commentModule.js

@@ -43,16 +43,12 @@ You are a senior engineer reviewing a ${fileType} file.
 Please:
 
 - Add summary comments (2-3 lines) at relevant points for greater class insights
-- Add clear, helpful inline comments to explain non-obvious logic inside functions.  
+- Add clear, helpful inline-comments to explain non-obvious logic inside functions.  
 - Use "${commentSyntax}" as the comment syntax appropriate for ${fileType}.
-- Preserve all original formatting, whitespace, and code exactly.
 
 Rules:
-- Return the full original chunk of code with added comments only.
-- Do NOT remove, change, or overwrite any existing code or comments.
-- Summaries should be brief but meaningful.
-- Inline comments should clarify complex or tricky parts only.
-- Do NOT add any “chunk” start/end markers, numbering, or metadata to the output.
+- Return the full original chunk of code with added comments.
+- Inline comments should clarify complex or tricky parts.
 
 ${input.content}
 

package/dist/pipeline/modules/generateTestsModule.js

@@ -10,32 +10,50 @@ export const generateTestsModule = {
             throw new Error('Missing filepath in pipeline context');
         const model = Config.getModel();
         const lang = detectFileType(filepath);
+        const repoRoot = Config.getIndexDir();
+        // Compute relative import path (repo-relative, without extension)
+        const relativePath = path.relative(repoRoot, filepath);
+        const { dir, name, ext } = path.parse(relativePath);
+        const importPath = './' + path.join(dir, name).replace(/\\/g, '/');
+        // Where the test should be written (next to source file)
+        const absParsed = path.parse(filepath);
+        const testPath = path.join(absParsed.dir, `${absParsed.name}.test${ext}`);
         const prompt = `
-      You are a senior ${lang.toUpperCase()} engineer. Given the following class or module, generate a Jest test file.
+You are a senior ${lang.toUpperCase()} engineer. Generate a Jest test file for the module below.
 
-      Guidelines:
-      - Use the 'jest' test framework
-      - Cover only one public method: the most relevant or central function
-      - Include one edge case for that method
-      - Preserve and consider existing code comments
-      - Name the file <original>.test.${path.extname(filepath).slice(1)}
-      - Only return valid ${lang} code
+Requirements:
+- Use the 'jest' test framework.
+- Always include imports at the top:
+  import { describe, it, expect } from '@jest/globals';
+  import * as moduleUnderTest from '${importPath}';
+- Cover only one public method: the most relevant or central function.
+- Include one edge case for that method.
+- Preserve and consider existing code comments in the module.
+- Only output valid ${lang} code; do not include markdown fences or explanations.
+- Use this scaffold at minimum:
 
-      --- CODE START ---
-      ${content}
-      --- CODE END ---
-    `.trim();
+import { describe, it, expect } from '@jest/globals';
+import * as moduleUnderTest from '${importPath}';
+
+describe('moduleUnderTest', () => {
+  it('should ...', () => {
+    // test implementation
+  });
+});
+
+--- MODULE CODE ---
+${content}
+--- END MODULE CODE ---
+`.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`);
         return {
             originalContent: content,
             content: response.content, // the test code
             filepath, // original file path
             newFilepath: testPath,
-            mode: "newFile" // where it *should* be written
+            mode: "newFile" // ensure it gets written as a new file
         };
     }
 };

package/dist/pipeline/registry/moduleRegistry.js

@@ -6,24 +6,88 @@ 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,
-    cleanup: cleanupModule,
-    summary: summaryModule,
-    tests: generateTestsModule,
-    suggest: commitSuggesterModule,
-    changelog: changelogModule,
-    cleantTests: cleanGeneratedTestsModule,
-    cleanComments: preserveCodeModule
+// Built-in modules with metadata
+export const builtInModules = {
+    comments: {
+        ...addCommentsModule,
+        group: 'documentation',
+        dependencies: {
+            after: ['cleanComments'], // run cleanComments after comments
+        },
+    },
+    cleanComments: {
+        ...preserveCodeModule,
+        group: 'documentation',
+    },
+    cleanup: {
+        ...cleanupModule,
+        group: 'maintenance',
+    },
+    summary: {
+        ...summaryModule,
+        group: 'documentation',
+    },
+    tests: {
+        ...generateTestsModule,
+        group: 'testing',
+        dependencies: {
+            after: ['cleanTests'], // run cleanTests after tests
+        },
+    },
+    cleanTests: {
+        ...cleanGeneratedTestsModule,
+        group: 'testing',
+    },
+    suggest: {
+        ...commitSuggesterModule,
+        group: 'git',
+    },
+    changelog: {
+        ...changelogModule,
+        group: 'git',
+    },
 };
+// Get module by name
 export function getModuleByName(name) {
     return builtInModules[name];
 }
 // Return module metadata for CLI or UI
 export function listAvailableModules() {
-    return Object.values(builtInModules).map(({ name, description }) => ({
+    return Object.values(builtInModules).map(({ name, description, group, dependencies }) => ({
         name,
         description: description || 'No description available',
+        group,
+        dependencies,
     }));
 }
+/**
+ * Resolve module execution order including before/after dependencies.
+ * Returns a unique ordered array of PromptModuleMeta.
+ */
+export function resolveModuleOrder(moduleNames) {
+    const resolved = [];
+    const visited = new Set();
+    function visit(name) {
+        if (visited.has(name))
+            return;
+        const mod = getModuleByName(name);
+        if (!mod)
+            return;
+        // Handle before dependencies first
+        if (mod.dependencies?.before) {
+            for (const dep of mod.dependencies.before)
+                visit(dep);
+        }
+        // Add the module itself
+        resolved.push(mod);
+        visited.add(name);
+        // Handle after dependencies
+        if (mod.dependencies?.after) {
+            for (const dep of mod.dependencies.after)
+                visit(dep);
+        }
+    }
+    for (const name of moduleNames)
+        visit(name);
+    return resolved;
+}

package/package.json

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