scai 0.1.8 → 0.1.9

package/dist/commands/CommitSuggesterCmd.js

@@ -7,17 +7,21 @@ function askUserToChoose(suggestions) {
             console.log(`${i + 1}) ${msg}`);
         });
         console.log(`${suggestions.length + 1}) 🔁 Regenerate suggestions`);
+        console.log(`${suggestions.length + 2}) ✍️  Write your own commit message`);
         const rl = readline.createInterface({
             input: process.stdin,
             output: process.stdout,
         });
-        rl.question(`\n👉 Choose a commit message [1-${suggestions.length + 1}]: `, (answer) => {
+        rl.question(`\n👉 Choose a commit message [1-${suggestions.length + 2}]: `, (answer) => {
             rl.close();
             const choice = parseInt(answer, 10);
-            if (isNaN(choice) || choice < 1 || choice > suggestions.length + 1) {
+            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)
             }
@@ -45,6 +49,18 @@ async function generateSuggestions(prompt) {
     }
     return messages;
 }
+function promptCustomMessage() {
+    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 async function suggestCommitMessage(options) {
     try {
         let diff = execSync("git diff", { encoding: "utf-8" }).trim();
@@ -65,13 +81,17 @@ ${diff}`;
         let message = null;
         while (message === null) {
             const suggestions = await generateSuggestions(prompt);
-            const choiceIndex = await askUserToChoose(suggestions);
-            if (choiceIndex === suggestions.length) {
+            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];
         }
         console.log(`\n✅ Selected commit message:\n${message}\n`);
         if (options.commit) {
@@ -80,7 +100,7 @@ ${diff}`;
                 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) {

package/dist/commands/CommitSuggesterCmd.refactored.js

@@ -1,44 +1,60 @@
-"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)
+// Prompt function asks user to choose a commit message from given suggestions
+function askUserToChoose(suggestions) {
+    // Create and close readline interface after getting user input
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    rl.question(...);
+    rl.close();
 }
-
-// Define an asynchronous function to ask for a user choice among the given suggestions
-async function askForChoice(options: { suggestions: string[] }): Promise<number> {
-  // ... (Existing code)
+// Fetches suggestions from the API and processes the response
+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(...);
 }
-
-// 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);
-  }
+// Export function for suggesting and committing a commit message if needed
+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 = `...`;
+        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');
+                continue;
+            }
+            message = suggestions[choiceIndex];
+        }
+        // Print the selected commit message and commit it if needed
+        console.log(...);
+        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.');
+        }
+    }
+    catch (err) {
+        // Print error message if an error occurs during the commit message suggestion process
+        console.error(...);
+    }
 }
-
-// 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/GitCmd.refactored.js

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

@@ -1,7 +1,6 @@
 import fs from 'fs/promises';
 import path from 'path';
 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 = {}) {
@@ -28,7 +27,7 @@ export async function handleRefactor(filepath, options = {}) {
         // Read source code
         const originalCode = await fs.readFile(filepath, 'utf-8');
         // Run through pipeline modules
-        const refactored = await runPromptPipeline([refactorModule, addCommentsModule, cleanupModule], { code: originalCode });
+        const refactored = await runPromptPipeline([addCommentsModule, cleanupModule], { code: originalCode });
         if (!refactored.trim())
             throw new Error('⚠️ Model returned empty result');
         // Save refactored output

package/dist/pipeline/modules/cleanupModule.js

@@ -1,34 +1,42 @@
+function isNaturalLanguageNoise(line) {
+    const trimmed = line.trim().toLowerCase();
+    return (trimmed.startsWith('i ') ||
+        trimmed.startsWith('here') ||
+        trimmed.startsWith('this') ||
+        trimmed.startsWith('the following') ||
+        trimmed.startsWith('below') ||
+        trimmed.startsWith('in this') ||
+        trimmed.startsWith('we have') ||
+        trimmed.includes('the code above') ||
+        trimmed.includes('ensures that') ||
+        trimmed.includes('it handles') ||
+        trimmed.includes('used to'));
+}
 export const cleanupModule = {
     name: 'cleanup',
-    description: 'Removes markdown formatting and explanations from the output',
+    description: 'Remove markdown fences and natural language noise from top/bottom of code',
     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() ?? '' };
+        let lines = code.trim().split('\n');
+        // ───── Clean top ─────
+        while (lines.length) {
+            const line = lines[0].trim();
+            if (line === '' || line.startsWith('```') || isNaturalLanguageNoise(line)) {
+                lines.shift();
+            }
+            else {
+                break;
+            }
+        }
+        // ───── Clean bottom ─────
+        while (lines.length) {
+            const line = lines[lines.length - 1].trim();
+            if (line === '' || line.startsWith('```') || isNaturalLanguageNoise(line)) {
+                lines.pop();
+            }
+            else {
+                break;
+            }
+        }
+        return { code: lines.join('\n').trim() };
     }
 };

package/dist/pipeline/modules/commentModule.js

@@ -5,9 +5,9 @@ export const addCommentsModule = {
         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)
+Add clear and helpful single-line // comments to complex parts of the code.
+- Do NOT remove or change in ANY way any parts of the code!
+- Output ALL of the original code with your comments included
 
 --- CODE START ---
 ${input.code}

package/dist/pipeline/modules/refactorModule.js

@@ -6,9 +6,8 @@ export const refactorModule = {
 You are a senior JavaScript/TypeScript engineer.
 
 Refactor the following code:
-- Split into ~10 line functions
-- Improve naming, structure, and clarity
-- Return ONLY the valid refactored code (no markdown)
+- 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.
 
 --- CODE START ---
 ${code}

package/dist/pipeline/runPipeline.js

@@ -2,8 +2,8 @@ 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(`⚙️ Running: ${mod.name}`);
         console.log("Current: ", current);
     }
     return current.code;

package/package.json

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