scai 0.1.9 → 0.1.11

package/README.md

@@ -5,23 +5,37 @@
 **scai** (Smart Commit AI) is a lightweight, privacy-focused CLI tool that uses local AI models (via [Ollama](https://ollama.com)) to help developers work faster and cleaner:
 
 - 🤖 Suggest high-quality Git commit messages  
-- ✨ Refactor messy code files  
-- 🧠 Check Git status and improve workflows  
+- ✨ Comments your code automatically
+- 🧠 Generate README updates based on your diff  
 - 🔒 100% local — no API keys, no cloud, no telemetry  
 
 ---
 
+**scai** follows the Unix philosophy — small, composable tools with powerful output.
+
 ## 🚀 Features
 
 - 💬 Generate commit messages from staged Git changes  
-- ✨ Refactor a single JavaScript file for improved readability  
-- 🔍 Check Git status with one command  
-- ⚡️ Powered by Ollama + local models like `llama3` and `mistral`  
+- ✨ Add comments to your code 
+- ⚡️ Powered by open local Ollama models like `mistral`  
 - 🛠️ CLI built with Node.js + TypeScript  
 - 🔒 No external services, full privacy by design  
 
 ---
 
+## ❤️ Philosophy: Why Local AI?
+
+We believe your code — and your workflow — should stay **yours**. scai runs entirely on your machine using open-source models and tools.
+
+No internet connection. No vendor lock-in. Just local, private, AI-enhanced developer experience.
+
+✅ Works entirely offline  
+✅ No API keys, cloud accounts, or telemetry  
+✅ Backed by open-source models  
+✅ Designed for CLI-first devs and scriptable workflows  
+
+---
+
 ## 📦 Installation
 
 1. **Install [Ollama](https://ollama.com)**  
@@ -61,7 +75,7 @@ This will:
 git add .
 
 # Let scai suggest a commit message
-scai commit
+scai suggest
 ```
 
 > Example output:
@@ -72,7 +86,7 @@ feat(api): add error handling to user service
 To automatically commit with the suggested message:
 
 ```bash
-scai commit --commit
+scai suggest --commit
 ```
 
 ---
@@ -91,6 +105,16 @@ path/to/refactored/file.refactored.js
 
 ---
 
+### 🧩 Generate Tests
+
+```bash
+scai generate-tests <file>
+```
+
+Automatically generates Jest test files for specified JavaScript/TypeScript modules.
+
+---
+
 ### 🔍 Check Git status
 
 ```bash
@@ -118,10 +142,3 @@ However:
 For full terms, see the [LICENSE](./LICENSE) file.
 
 ---
-
-## ❤️ Why Local-First?
-
-We believe your code — and your workflow — should stay **yours**. scai runs entirely on your machine using open-source models and tools.
-
-No internet connection. No vendor lock-in. Just local, private, AI-enhanced developer experience.
-

package/dist/commands/CommitSuggesterCmd.refactored.js

@@ -1,60 +1,116 @@
-// Prompt function asks user to choose a commit message from given suggestions
-function askUserToChoose(suggestions) {
-    // Create and close readline interface after getting user input
+// Import required modules
+import { execSync } from 'child_process';
+import readline from 'readline';
+// Function to ask the user to choose a commit message suggestion
+async function askUserToChoose(suggestions) {
+    // Create an interface for reading and writing to the console
     const rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout,
     });
-    rl.question(...);
-    rl.close();
+    // Show AI-suggested commit messages to the user and ask for their choice
+    return new Promise((resolve) => {
+        console.log('\n💡 AI-suggested commit messages:\n');
+        suggestions.forEach((msg, i) => {
+            console.log(`${i + 1}) ${msg}`);
+        });
+        console.log(`${suggestions.length + 1}) 🔁 Regenerate suggestions`);
+        console.log(`${suggestions.length + 2}) ✍️  Write your own commit message`);
+        rl.question(`\n👉 Choose a commit message [1-${suggestions.length + 2}]: `, (answer) => {
+            // Close the readline interface and resolve the promise with user choice
+            rl.close();
+            const choice = parseInt(answer, 10);
+            if (isNaN(choice) || choice < 1 || choice > suggestions.length + 2) {
+                console.log('⚠️  Invalid selection. Using the first suggestion by default.');
+                resolve(0);
+            }
+            else if (choice === suggestions.length + 2) {
+                resolve('custom');
+            }
+            else {
+                resolve(choice - 1); // Return 0-based index (0 to 3)
+            }
+        });
+    });
 }
-// Fetches suggestions from the API and processes the response
+// Async function to generate commit message suggestions using an API call
 async function generateSuggestions(prompt) {
-    // Fetch JSON data from the given API endpoint
-    const res = await fetch("http://localhost:11434/api/generate", { ... });
-    // Filter out any invalid lines from the response and map them to a list of commit messages
-    const messages = lines.map(...);
+    // Fetch the suggestions from an API and return them as an array of strings
+    const res = await fetch("http://localhost:11434/api/generate", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            model: "llama3",
+            prompt,
+            stream: false,
+        }),
+    });
+    const { response } = await res.json();
+    // Check for validity of the LLM response and return an array of commit messages
+    if (!response || typeof response !== 'string') {
+        throw new Error('Invalid LLM response');
+    }
+    const lines = response.trim().split('\n').filter(line => /^\d+\.\s+/.test(line));
+    return lines.map(line => line.replace(/^\d+\.\s+/, '').replace(/^"(.*)"$/, '$1').trim());
+}
+// Function to prompt the user for a custom commit message
+async function promptCustomMessage() {
+    // Read the user's input for their custom commit message
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question('\n📝 Enter your custom commit message:\n> ', (input) => {
+            rl.close();
+            resolve(input.trim());
+        });
+    });
 }
-// Export function for suggesting and committing a commit message if needed
+// Export the main function to suggest a commit message based on user input and generated suggestions
 export async function suggestCommitMessage(options) {
     try {
-        // Get the diff between local changes and staged changes
         let diff = execSync("git diff", { encoding: "utf-8" }).trim();
         if (!diff) {
             diff = execSync("git diff --cached", { encoding: "utf-8" }).trim();
         }
-        // Check if there are any changes to suggest a message for
         if (!diff) {
             console.log('⚠️  No staged changes to suggest a message for.');
             return;
         }
-        // Construct the prompt based on the diff and generate suggestions using the 'generateSuggestions' function
-        const prompt = `...`;
+        const prompt = `Suggest 3 concise, conventional Git commit message options for this diff. Return ONLY the commit messages, numbered 1 to 3, like so:
+1. ...
+2. ...
+3. ...
+
+Here is the diff:
+${diff}`;
         let message = null;
-        // Continuously ask user for their choice until a valid commit message is selected
         while (message === null) {
             const suggestions = await generateSuggestions(prompt);
-            // Ask user to choose from the given suggestions and handle 'Regenerate' option
-            const choiceIndex = await askUserToChoose(suggestions);
-            if (choiceIndex === suggestions.length) {
-                console.log('🔄 Regenerating suggestions...\n');
+            const choice = await askUserToChoose(suggestions);
+            if (choice === suggestions.length) {
+                // User chose "Regenerate"
+                console.log('\n🔄 Regenerating suggestions...\n');
                 continue;
             }
-            message = suggestions[choiceIndex];
+            if (choice === 'custom') {
+                message = await promptCustomMessage();
+                break;
+            }
+            message = suggestions[choice];
         }
-        // Print the selected commit message and commit it if needed
-        console.log(...);
+        console.log(`\n✅ Selected commit message:\n${message}\n`);
         if (options.commit) {
             const commitDiff = execSync("git diff", { encoding: "utf-8" }).trim();
             if (commitDiff) {
                 execSync("git add .", { encoding: "utf-8" });
             }
             execSync(`git commit -m "${message.replace(/"/g, '\\"')}"`, { stdio: 'inherit' });
-            console.log('✅ Committed with AI-suggested message.');
+            console.log('✅ Committed with selected message.');
         }
     }
     catch (err) {
-        // Print error message if an error occurs during the commit message suggestion process
-        console.error(...);
+        console.error('❌ Error in commit message suggestion:', err.message);
     }
 }

package/dist/commands/ReadmeCmd.js

@@ -3,9 +3,12 @@ import fs from 'fs/promises';
 import path from 'path';
 export async function updateReadmeIfNeeded() {
     try {
-        const diff = execSync("git diff", { encoding: "utf-8" }).trim();
+        let diff = execSync("git diff", { encoding: "utf-8" }).trim();
         if (!diff) {
-            console.log("⚠️ No changes to analyze in the working directory.");
+            diff = execSync("git diff --cached", { encoding: "utf-8" }).trim();
+        }
+        if (!diff) {
+            console.log('⚠️  No staged changes to suggest a message for.');
             return;
         }
         const readmePath = path.resolve("README.md");

package/dist/commands/RefactorCmd.js

@@ -28,10 +28,10 @@ export async function handleRefactor(filepath, options = {}) {
         const originalCode = await fs.readFile(filepath, 'utf-8');
         // Run through pipeline modules
         const refactored = await runPromptPipeline([addCommentsModule, cleanupModule], { code: originalCode });
-        if (!refactored.trim())
+        if (!refactored.code.trim())
             throw new Error('⚠️ Model returned empty result');
         // Save refactored output
-        await fs.writeFile(refactoredPath, refactored, 'utf-8');
+        await fs.writeFile(refactoredPath, refactored.code, 'utf-8');
         console.log(`✅ Refactored code saved to: ${refactoredPath}`);
         console.log(`ℹ️ Run again with '--apply' to overwrite the original.`);
     }

package/dist/commands/TestGenCmd.js

@@ -0,0 +1,14 @@
+import fs from 'fs/promises';
+import { generateTestsModule } from '../pipeline/modules/generateTestsModule.js';
+import { cleanupModule } from '../pipeline/modules/cleanupModule.js';
+import { runPromptPipeline } from '../pipeline/runPipeline.js';
+export async function generateTests(filepath) {
+    try {
+        const code = await fs.readFile(filepath, 'utf-8');
+        const result = await runPromptPipeline([generateTestsModule, cleanupModule], { code, filepath });
+        console.log('✅ Test generated and cleaned up.');
+    }
+    catch (err) {
+        console.error('❌ Error generating tests:', err.message);
+    }
+}

package/dist/index.js

@@ -5,6 +5,7 @@ import { checkGit } from "./commands/GitCmd.js";
 import { suggestCommitMessage } from "./commands/CommitSuggesterCmd.js";
 import { handleRefactor } from "./commands/RefactorCmd.js";
 import { updateReadmeIfNeeded } from "./commands/ReadmeCmd.js";
+import { generateTests } from "./commands/TestGenCmd.js";
 // Import the model check and initialization logic
 import { bootstrap } from './modelSetup.js';
 // Create the CLI instance
@@ -27,7 +28,7 @@ cmd
     .description('Check Git status')
     .action(checkGit);
 cmd
-    .command('commit')
+    .command('suggest')
     .description('Suggest a commit message from staged changes')
     .option('-c, --commit', 'Automatically commit with suggested message')
     .action(suggestCommitMessage);
@@ -40,5 +41,9 @@ cmd
     .command('readme')
     .description('Update README.md if relevant changes were made')
     .action(updateReadmeIfNeeded);
+cmd
+    .command('generate-tests <file>')
+    .description('Generate a Jest test file for the specified JS/TS module')
+    .action((file) => generateTests(file));
 // Parse CLI arguments
 cmd.parse(process.argv);

package/dist/jest.config.js

@@ -0,0 +1,11 @@
+const config = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    setupFilesAfterEnv: ['./jest.setup.ts'],
+    transform: {
+        '^.+\\.ts$': 'ts-jest',
+    },
+    moduleFileExtensions: ['ts', 'js', 'json', 'node'],
+    testPathIgnorePatterns: ['/node_modules/', '/dist/'],
+};
+export default config;

package/dist/jest.setup.js

@@ -0,0 +1,14 @@
+import { jest } from '@jest/globals';
+// jest.setup.ts
+// Mock the global fetch function in Jest for Node.js 18+
+global.fetch = jest.fn(() => Promise.resolve({
+    json: () => Promise.resolve({ response: 'Mocked Commit Message' }),
+    ok: true,
+    status: 200,
+    statusText: 'OK',
+    headers: new Headers(),
+    redirected: false,
+    type: 'default',
+    url: 'https://mocked-url.com',
+}) // Type assertion for `Response` object
+);

package/dist/pipeline/modules/generateTestsModule.js

@@ -0,0 +1,42 @@
+import fs from 'fs/promises';
+import path from 'path';
+export const generateTestsModule = {
+    name: 'generateTests',
+    description: 'Generate a Jest test file for the class/module',
+    async run({ code, filepath }) {
+        const prompt = `
+You're a senior TypeScript developer. Given the following class or module, generate a Jest test file.
+
+Guidelines:
+- Use the 'jest' test framework
+- Cover public methods and one edge case
+- Name the file <original>.test.ts
+- Only return valid TypeScript code
+
+--- CODE START ---
+${code}
+--- CODE END ---
+    `.trim();
+        const res = await fetch('http://localhost:11434/api/generate', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model: 'mistral',
+                prompt,
+                stream: false
+            })
+        });
+        const data = await res.json();
+        const testCode = data.response?.trim();
+        if (!testCode)
+            throw new Error('⚠️ No test code returned from model');
+        // Determine test file path next to refactored file
+        if (!filepath)
+            throw new Error('Missing filepath in pipeline context');
+        const { dir, name } = path.parse(filepath);
+        const testPath = path.join(dir, `${name}.test.ts`);
+        await fs.writeFile(testPath, testCode, 'utf-8');
+        console.log(`✅ Test file saved to: ${testPath}`);
+        return { code, filepath }; // unchanged input
+    }
+};

package/dist/pipeline/modules/refactorModule.js

@@ -6,8 +6,9 @@ export const refactorModule = {
 You are a senior JavaScript/TypeScript engineer.
 
 Refactor the following code:
-- Refactor all functions longer than 20 lines by extracting logical parts into smaller helper functions. 
-- Each resulting function should aim for clarity and ideally be under 20 lines, unless splitting would harm readability or functionality.
+- Refactor only long and complex functions 
+- Keep original names and semantics.
+- Do NOT insert comments
 
 --- CODE START ---
 ${code}

package/dist/pipeline/runPipeline.js

@@ -1,10 +1,23 @@
 export async function runPromptPipeline(modules, input) {
     let current = input;
-    console.log('Input: ', input);
+    // Add flag or condition for logging (optional)
+    const isDebug = true;
+    if (isDebug) {
+        console.log('Input: ', input);
+    }
     for (const mod of modules) {
-        current = await mod.run(current);
-        console.log(`⚙️ Running: ${mod.name}`);
-        console.log("Current: ", current);
+        try {
+            current = await mod.run(current);
+            if (isDebug) {
+                console.log(`⚙️ Running: ${mod.name}`);
+                console.log("Current: ", current);
+            }
+        }
+        catch (error) {
+            console.error(`❌ Error in ${mod.name}:`, error instanceof Error ? error.message : error);
+            throw new Error(`Pipeline failed at module ${mod.name}`);
+        }
     }
-    return current.code;
+    // Return the output, assuming 'code' holds the relevant transformed content
+    return { code: current.code }; // Ensure the return type matches PromptOutput
 }

package/dist/utils/runTests.js

@@ -0,0 +1,11 @@
+import { execSync } from 'child_process';
+export function runJestTest(testFile) {
+    try {
+        execSync(`npx jest ${testFile} --silent`, { stdio: 'inherit' });
+        return true;
+    }
+    catch (err) {
+        console.error(`❌ Tests failed for ${testFile}`);
+        return false;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scai",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "type": "module",
   "bin": {
     "scai": "./dist/index.js"
@@ -11,7 +11,14 @@
   },
   "author": "Rasmus Uhd Norgaard",
   "license": "SEE LICENSE IN LICENSE",
-  "keywords": ["cli", "ai", "refactor", "devtools", "local", "typescript"],
+  "keywords": [
+    "cli",
+    "ai",
+    "refactor",
+    "devtools",
+    "local",
+    "typescript"
+  ],
   "scripts": {
     "build": "tsc",
     "start": "node dist/index.js"
@@ -20,11 +27,14 @@
     "commander": "^11.0.0"
   },
   "devDependencies": {
+    "@types/jest": "^30.0.0",
     "@types/node": "^24.0.1",
+    "jest": "^30.0.2",
+    "ts-jest": "^29.4.0",
     "typescript": "^5.8.3"
   },
   "files": [
     "dist/",
-    "README.md"	
+    "README.md"
   ]
-}
+}

package/dist/commands/GitCmd.refactored.js

@@ -1,12 +0,0 @@
-"use strict";
-// Import the 'child_process' module from 'node:child_process'.
-// Export a function called 'checkGit', which checks the Git status.
-// Try to execute the command "git rev-parse --is-inside-work-tree" with ignored stdio, ensuring we're in a Git repository.
-// If the Git working directory is clean (no uncommitted changes), log a message indicating this.
-// Otherwise, if there are uncommitted changes, log a warning message.
-// Execute "git status --porcelain" to get a compact representation of the current Git state and store its output as a string.
-// Trim any leading/trailing whitespace from the string.
-// Compare the trimmed string's length to zero. If it is equal to zero, the working directory is clean (length > 0 indicates uncommitted changes).
-// If the Git branch matches the head commit hash of 'origin/main', log a message indicating that the current branch is up-to-date with 'origin/main'.
-// Otherwise, log a message indicating that the current branch is not up-to-date with 'origin/main'.
-// Catch any errors that may occur during Git execution and log an error message.

package/dist/commands/RefactorCmd.refactored.js

@@ -1,8 +0,0 @@
-"use strict";
-// Summary of refactor:
-// - Normalized file paths by adding './' if not present
-// - Parsed normalized file paths into their directory, name, and extension
-// - Generated a refactored file path using the original file's directory, name, and extension along with the '.refactored' suffix
-// - Handled the refactor operation for a given file path and options (apply flag to decide whether to overwrite the original file or not)
-// - If apply is set, attempted to read the refactored code from the refactored file path and overwrite the original file if it exists.
-// - If not, read the original code from the file, passed it through a pipeline for refactoring, saved the refactored code to a new file path, and provided an option to run again with '--apply' to overwrite the original.

package/dist/pipeline/modules/stripMarkdownModule.js

@@ -1,15 +0,0 @@
-export const stripMarkdownModule = {
-    name: 'stripMarkdown',
-    description: 'Remove surrounding markdown and explanations from LLM output',
-    async run({ code }) {
-        let cleaned = code.trim();
-        // Remove common intro text like "Here is the refactored code:"
-        cleaned = cleaned.replace(/^.*?(?=\n|```|import|function|const|let)/is, '');
-        // Remove triple backtick blocks and optional language tags
-        cleaned = cleaned.replace(/^```[a-z]*\n?/i, '');
-        cleaned = cleaned.replace(/```$/, '');
-        // Remove any leftover empty lines at top and bottom
-        cleaned = cleaned.trim();
-        return { code: cleaned };
-    }
-};