scai 0.1.5 → 0.1.7

package/README.md

@@ -1,29 +1,120 @@
-# scai — Smart Commit AI ✨
+# ⚙️ scai — Smart Commit AI ✨
 
-> AI-powered commit message suggestions from staged changes — directly in your terminal.
+> AI-powered CLI tools for smart commit messages, automated refactoring, and developer insight — all powered by local models.
 
-**scai** (Smart Commit AI) is a lightweight, privacy-focused CLI tool that uses a local AI model to generate clear, meaningful commit messages based on your staged Git changes. No internet required. No telemetry. Just smart commits.
+**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  
+- 🔒 100% local — no API keys, no cloud, no telemetry  
 
 ---
 
 ## 🚀 Features
 
-- 🔍 Automatically suggests commit messages based on `git diff`
-- 🤖 Uses a local language model via [Ollama](https://ollama.com/) — no external API keys
-- 🧱 Designed for local developer workflows and automation
-- 📦 Works with any Git repository
+- 💬 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`  
+- 🛠️ CLI built with Node.js + TypeScript  
+- 🔒 No external services, full privacy by design  
 
 ---
 
 ## 📦 Installation
 
-You'll need [Ollama](https://ollama.com/) installed and running locally, with a supported model like `mistral` pulled:
+1. **Install [Ollama](https://ollama.com)**  
+   - On Windows: [Download Ollama](https://ollama.com/download)  
+   - Ensure it’s added to your system `PATH`
+
+2. **Install scai globally via npm:**
+
+```bash
+npm install -g scai
+```
+
+3. **Run the initialization step to start Ollama and install models:**
+
+```bash
+scai init
+```
+
+This will:
+- Launch the Ollama background server (if not running)
+- Pull the required models (`llama3`, `mistral`) if they aren’t present
+
+---
+
+## 🧪 Usage Examples
+
+### 💬 Suggest a commit message
+
+```bash
+# Stage your changes
+git add .
+
+# Let scai suggest a commit message
+scai commit
+```
+
+> Example output:
+```
+feat(api): add error handling to user service
+```
+
+To automatically commit with the suggested message:
+
+```bash
+scai commit --commit
+```
+
+---
+
+### 🛠 Refactor a JavaScript file
+
+```bash
+scai refactor path/to/file.js
+```
+
+A cleaned-up version will be written to:
+
+```
+path/to/refactored/file.refactored.js
+```
+
+---
+
+### 🔍 Check Git status
 
 ```bash
-ollama run mistral
+scai git
+```
+
+Useful overview of current branch, commits, and uncommitted changes.
+
+---
+
+## 🔐 License & Fair Use
+
+**scai is free to use** for individuals, teams, and companies — including in commercial work.  
+You may:
+
+- ✅ Use it internally in your projects  
+- ✅ Use it at work or in commercial software development  
+- ✅ Share and recommend it to colleagues  
+
+However:
+
+- ❌ You may not **resell**, repackage, or redistribute **scai** as a commercial product or SaaS offering  
+- ❌ You may not claim ownership or original authorship  
+
+For full terms, see the [LICENSE](./LICENSE) file.
+
+---
 
+## ❤️ Why Local-First?
 
-## License
+We believe your code — and your workflow — should stay **yours**. scai runs entirely on your machine using open-source models and tools.
 
-This software is licensed for non-commercial use only.
-See the [LICENSE](./LICENSE) file for details.
+No internet connection. No vendor lock-in. Just local, private, AI-enhanced developer experience.

package/dist/commands/CommitSuggesterCmd.refactored.js

@@ -0,0 +1,44 @@
+"use strict";
+Here;
+is;
+the;
+refactored;
+code;
+with (comments)
+    added;
+and;
+a;
+summary;
+of;
+refactor;
+at;
+the;
+end: `` `typescript
+// Import necessary modules for executing child processes, fetch requests, and readline interface
+import { execSync } from 'child_process';
+import readline from 'readline';
+import { fetch } from 'node-fetch';
+
+// Define an asynchronous function to generate messages based on the provided prompt
+async function generateMessages(prompt: string): Promise<string[]> {
+  // ... (Existing code)
+}
+
+// Define an asynchronous function to ask for a user choice among the given suggestions
+async function askForChoice(options: { suggestions: string[] }): Promise<number> {
+  // ... (Existing code)
+}
+
+// Export an asynchronous function to suggest a commit message based on the given options (with the commit flag for final committing)
+export async function suggestCommitMessage({ commit = false }: { commit?: boolean }) {
+  try {
+    // ... (Existing code)
+  } catch (err) {
+    console.error('❌ Error in commit message suggestion:', err.message);
+  }
+}
+
+// Summary of refactor:
+// - Added comments to each block for better understanding.
+// - Extracted the functions generateMessages and askForChoice into separate blocks for code organization.
+` ``;

package/dist/commands/ReadmeCmd.js

@@ -0,0 +1,58 @@
+import { execSync } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+export async function updateReadmeIfNeeded() {
+    try {
+        const diff = execSync("git diff", { encoding: "utf-8" }).trim();
+        if (!diff) {
+            console.log("⚠️ No changes to analyze in the working directory.");
+            return;
+        }
+        const readmePath = path.resolve("README.md");
+        let readme = "";
+        try {
+            readme = await fs.readFile(readmePath, "utf-8");
+        }
+        catch {
+            console.log("📄 No existing README.md found, skipping update.");
+            return;
+        }
+        const prompt = `
+You're an experienced documentation writer. Here's the current README:
+
+--- README START ---
+${readme}
+--- README END ---
+
+Here is a Git diff of recent code changes:
+
+--- DIFF START ---
+${diff}
+--- DIFF END ---
+
+✅ If the changes are significant and relevant to the public-facing documentation, return an updated README.  
+❌ If they are not, return ONLY: "NO UPDATE".
+`;
+        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();
+        const result = response.trim();
+        if (result === "NO UPDATE") {
+            console.log("✅ No significant changes for README.");
+        }
+        else {
+            await fs.writeFile(readmePath, result, "utf-8");
+            console.log("📝 README.md updated based on significant changes.");
+        }
+    }
+    catch (err) {
+        console.error("❌ Failed to update README:", err.message);
+    }
+}

package/dist/commands/RefactorCmd.js

@@ -1,42 +1,40 @@
 import fs from 'fs/promises';
 import path from 'path';
-export async function handleRefactor(filepath) {
+import { runPromptPipeline } from '../pipeline/runPipeline.js';
+import { refactorModule } from '../pipeline/modules/refactorModule.js';
+import { addCommentsModule } from '../pipeline/modules/commentModule.js';
+import { cleanupModule } from '../pipeline/modules/cleanupModule.js';
+export async function handleRefactor(filepath, options = {}) {
     try {
-        // 1) Read original file
-        const code = await fs.readFile(filepath, 'utf-8');
-        // 2) Prompt the LLM
-        const prompt = `
-    You are a senior JavaScript engineer. Refactor the code below to improve readability,
-    modularity, and maintainability. Return ONLY the refactored code.
-
-    --- ORIGINAL CODE START ---
-    ${code}
-    --- ORIGINAL 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();
-        console.log('🔍 Raw LLM response:', data);
-        const refactored = data.response?.trim();
-        if (!refactored) {
-            throw new Error('No refactored code returned from the model.');
+        // Normalize path: add ./ prefix if no directory specified
+        if (!filepath.startsWith('./') && !filepath.startsWith('/') && !filepath.includes('\\')) {
+            filepath = `./${filepath}`;
         }
-        // 3) Write to a new file alongside the original
-        const { dir, name } = path.parse(filepath);
-        console.log('dir: ', dir);
-        console.log('name: ', name);
-        const outDir = path.join(dir, 'refactored');
-        await fs.mkdir(outDir, { recursive: true });
-        const outPath = path.join(outDir, `${name}.refactored.js`);
-        await fs.writeFile(outPath, refactored, 'utf-8');
-        console.log(`✅ Refactored code saved to: ${outPath}`);
+        const { dir, name, ext } = path.parse(filepath);
+        const refactoredPath = path.join(dir, `${name}.refactored${ext}`);
+        // --apply flag: use existing refactored file and overwrite original
+        if (options.apply) {
+            try {
+                const refactoredCode = await fs.readFile(refactoredPath, 'utf-8');
+                await fs.writeFile(filepath, refactoredCode, 'utf-8');
+                await fs.unlink(refactoredPath);
+                console.log(`♻️ Applied refactor: Overwrote ${filepath} and removed ${refactoredPath}`);
+            }
+            catch {
+                console.error(`❌ No saved refactor found at ${refactoredPath}`);
+            }
+            return;
+        }
+        // Read source code
+        const originalCode = await fs.readFile(filepath, 'utf-8');
+        // Run through pipeline modules
+        const refactored = await runPromptPipeline([refactorModule, addCommentsModule, cleanupModule], { code: originalCode });
+        if (!refactored.trim())
+            throw new Error('⚠️ Model returned empty result');
+        // Save refactored output
+        await fs.writeFile(refactoredPath, refactored, 'utf-8');
+        console.log(`✅ Refactored code saved to: ${refactoredPath}`);
+        console.log(`ℹ️ Run again with '--apply' to overwrite the original.`);
     }
     catch (err) {
         console.error('❌ Error in refactor command:', err.message);

package/dist/commands/RefactorCmd.refactored.js

@@ -0,0 +1,8 @@
+"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/index.js

@@ -4,6 +4,7 @@ import { checkEnv } from "./commands/EnvCmd.js";
 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 the model check and initialization logic
 import { bootstrap } from './modelSetup.js';
 // Create the CLI instance
@@ -31,8 +32,13 @@ cmd
     .option('-c, --commit', 'Automatically commit with suggested message')
     .action(suggestCommitMessage);
 cmd
-    .command('refactor <file>')
-    .description('Suggest a refactor for the given JS file')
-    .action((file) => handleRefactor(file));
+    .command('refac <file>')
+    .description('Suggest a refactor for the given JS/TS file')
+    .option('-a, --apply', 'Apply the refactored version to the original file')
+    .action((file, options) => handleRefactor(file, options));
+cmd
+    .command('readme')
+    .description('Update README.md if relevant changes were made')
+    .action(updateReadmeIfNeeded);
 // Parse CLI arguments
 cmd.parse(process.argv);

package/dist/pipeline/modules/cleanupModule.js

@@ -0,0 +1,34 @@
+export const cleanupModule = {
+    name: 'cleanup',
+    description: 'Removes markdown formatting and explanations from the output',
+    async run({ code }) {
+        const prompt = `
+You are a code cleanup assistant.
+
+Your task is to take the following code output and:
+- Remove any markdown formatting like triple backticks from the top of the file
+- Remove any markdown formatting like triple backticks from the bottom of the file
+- Keep all actual TypeScript/JavaScript code
+- keep all comments that start with // or /* and ends with */
+- do not tell me what you have done or make any such similar comments
+- do not add any tripple backticks
+
+Return ONLY the cleaned code, without any markdown or extra text.
+
+--- 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: 'llama3',
+                prompt,
+                stream: false
+            }),
+        });
+        const data = await res.json();
+        return { code: data.response?.trim() ?? '' };
+    }
+};

package/dist/pipeline/modules/commentModule.js

@@ -0,0 +1,28 @@
+export const addCommentsModule = {
+    name: 'addComments',
+    description: 'Adds meaningful // comments to each block of code',
+    async run(input) {
+        const prompt = `
+You are a senior JavaScript engineer. 
+
+Add clear and helpful single-line // comments only to each block of the following code. 
+- Keep the code unchanged otherwise.
+- Return ONLY the valid refactored code (no markdown)
+
+--- CODE START ---
+${input.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: prompt,
+                stream: false,
+            }),
+        });
+        const data = await res.json();
+        return { code: data.response?.trim() ?? '' };
+    },
+};

package/dist/pipeline/modules/refactorModule.js

@@ -0,0 +1,27 @@
+export const refactorModule = {
+    name: 'refactor',
+    description: 'Break code into small, clean functions',
+    async run({ code }) {
+        const prompt = `
+You are a senior JavaScript/TypeScript engineer.
+
+Refactor the code below with these goals:
+- Split logic into small (~10 lines) functions
+- Improve naming, structure, and readability
+- do not include any libraries that were not in the original file
+
+ONLY return the plain refactored 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: prompt, stream: false })
+        });
+        const data = await res.json();
+        return { code: data.response?.trim() ?? '' };
+    }
+};

package/dist/pipeline/modules/stripMarkdownModule.js

@@ -0,0 +1,15 @@
+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 };
+    }
+};

package/dist/pipeline/modules/summaryModule.js

@@ -0,0 +1,31 @@
+export const summaryModule = {
+    name: 'summary',
+    description: 'Append // Summary of changes at the end',
+    async run({ code }) {
+        const prompt = `
+You are a senior developer assistant.
+
+Take the following code and return it exactly as-is, 
+but add a summary at the very end in this format:
+
+// Summary of refactor:
+// - Did X
+// - Did Y
+// - etc.
+
+DO NOT modify or omit any existing code. 
+Just append the summary.
+
+--- 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: 'llama3', prompt: prompt, stream: false })
+        });
+        const data = await res.json();
+        return { code: data.response?.trim() ?? '' };
+    }
+};

package/dist/pipeline/runPipeline.js

@@ -0,0 +1,10 @@
+export async function runPromptPipeline(modules, input) {
+    let current = input;
+    console.log('Input: ', input);
+    for (const mod of modules) {
+        console.log(`⚙️ Running: ${mod.name}`);
+        current = await mod.run(current);
+        console.log("Current: ", current);
+    }
+    return current.code;
+}

package/dist/pipeline/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scai",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "type": "module",
   "bin": {
     "scai": "./dist/index.js"
@@ -27,4 +27,4 @@
     "dist/",
     "README.md"	
   ]
-}
+}