scai 0.1.32 → 0.1.33

package/README.md

@@ -59,20 +59,48 @@ scai runs entirely on your machine and doesn't require cloud APIs or API keys. T
 
 ### 🔧 Git Commit Suggestions
 
+Use AI to suggest a meaningful commit message based on your staged code:
+
 ```bash
 git add .
 scai git sugg
 ```
 
-Suggests a meaningful commit message based on your staged code.
-To auto-commit:
+To automatically commit with the selected suggestion:
 
 ```bash
 scai git sugg --commit
 ```
 
+You can also include a changelog entry along with the commit:
+
+```bash
+scai git sugg --commit --changelog
+```
+
+This will:
+1. Suggest a commit message based on your `git diff --cached`
+2. Propose a changelog entry (if relevant)
+3. Allow you to approve, regenerate, or skip the changelog
+4. Automatically stage and commit the changes
+
 ---
 
+### 📝 Generate a Standalone Changelog Entry
+
+If you want to generate a changelog entry without committing:
+
+```bash
+scai gen changelog
+```
+
+This will:
+- Analyze the current `git diff` (staged or unstaged)
+- Propose a list of **user-facing changes** in clean markdown bullet points
+- Let you accept, regenerate, or skip the update
+- Append the entry to `CHANGELOG.md` and stage it if accepted
+
+
 ### 🛠️ Code Generation Commands (`gen` group)
 
 ```bash

package/dist/commands/ChangeLogUpdateCmd.js

@@ -1,39 +1,87 @@
-// src/commands/handleChangelogUpdate.ts
+// src/commands/ChangeLogUpdateCmd.ts
 import { execSync } from 'child_process';
 import fs from 'fs/promises';
 import path from 'path';
 import { runModulePipeline } from '../pipeline/runModulePipeline.js';
 import { changelogModule } from '../pipeline/modules/changeLogModule.js';
-export async function handleChangelogUpdate() {
+import { askChangelogApproval } from '../utils/changeLogPrompt.js';
+export async function handleStandaloneChangelogUpdate() {
+    let diff = execSync("git diff", { encoding: "utf-8", stdio: "pipe" }).trim();
+    if (!diff) {
+        diff = execSync("git diff --cached", { encoding: "utf-8", stdio: "pipe" }).trim();
+    }
+    if (!diff) {
+        console.log('⚠️ No changes detected for changelog.');
+        return;
+    }
+    let entry = await generateChangelogEntry(diff);
+    if (!entry) {
+        console.log('⚠️ No significant changes found.');
+        return;
+    }
+    while (true) {
+        const userChoice = await askChangelogApproval(entry);
+        if (userChoice === 'yes') {
+            const path = await updateChangelogFile(entry);
+            console.log(`✅ CHANGELOG.md updated: ${path}`);
+            break;
+        }
+        else if (userChoice === 'redo') {
+            console.log('🔁 Regenerating changelog...');
+            entry = await generateChangelogEntry(diff);
+            if (!entry) {
+                console.log('⚠️ Could not regenerate entry. Exiting.');
+                break;
+            }
+        }
+        else {
+            console.log('❌ Skipped changelog update.');
+            break;
+        }
+    }
+}
+export async function generateChangelogEntry(diff) {
     try {
-        let diff = execSync("git diff", { encoding: "utf-8" }).trim();
+        // If no diff is provided, fetch the current diff from git silently
         if (!diff) {
-            diff = execSync("git diff --cached", { encoding: "utf-8" }).trim();
+            diff = execSync("git diff", { encoding: "utf-8", stdio: 'pipe' }).trim();
+            // If no unstaged changes, fall back to staged changes
+            if (!diff) {
+                diff = execSync("git diff --cached", { encoding: "utf-8", stdio: 'pipe' }).trim();
+            }
         }
         if (!diff) {
-            console.log("⚠️  No staged or unstaged changes to include in changelog.");
-            return;
+            // No changes found, auto cancel by returning null
+            console.log('⚠️ No changes detected for the changelog.');
+            return null;
         }
+        // Generate the changelog entry using the diff silently
         const result = await runModulePipeline([changelogModule], { content: diff });
-        if (!result.content.trim()) {
-            console.log("✅ No significant changes for changelog.");
-            return;
-        }
-        const root = execSync("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
-        const changelogPath = path.join(root, "CHANGELOG.md");
-        let existing = "";
-        try {
-            existing = await fs.readFile(changelogPath, "utf-8");
+        const output = result?.summary?.trim();
+        if (!output || output === 'NO UPDATE') {
+            // Auto-cancel if no update
+            console.log('⚠️ No significant changes detected for changelog.');
+            return null;
         }
-        catch {
-            console.log("📄 Creating new CHANGELOG.md");
-        }
-        const today = new Date().toISOString().split("T")[0];
-        const newEntry = `\n\n## ${today}\n\n${result.content}`;
-        await fs.writeFile(changelogPath, existing + newEntry, "utf-8");
-        console.log("📝 CHANGELOG.md updated.");
+        return output;
     }
     catch (err) {
-        console.error("❌ Failed to update changelog:", err.message);
+        console.error("❌ Failed to generate changelog entry:", err.message);
+        return null;
+    }
+}
+export async function updateChangelogFile(entry) {
+    const root = execSync("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
+    const changelogPath = path.join(root, "CHANGELOG.md");
+    let existing = '';
+    try {
+        existing = await fs.readFile(changelogPath, 'utf-8');
+    }
+    catch {
+        console.log("📄 Creating new CHANGELOG.md");
     }
+    const today = new Date().toISOString().split("T")[0];
+    const newEntry = `\n\n## ${today}\n\n${entry.trim()}`;
+    await fs.writeFile(changelogPath, existing + newEntry, 'utf-8');
+    return changelogPath;
 }

package/dist/commands/CommitSuggesterCmd.js

@@ -2,6 +2,8 @@
 import { execSync } from 'child_process';
 import readline from 'readline';
 import { commitSuggesterModule } from '../pipeline/modules/commitSuggesterModule.js';
+import { generateChangelogEntry, updateChangelogFile } from './ChangeLogUpdateCmd.js';
+import { askChangelogApproval } from '../utils/changeLogPrompt.js';
 function askUserToChoose(suggestions) {
     return new Promise((resolve) => {
         console.log('\n💡 AI-suggested commit messages:\n');
@@ -51,30 +53,48 @@ function promptCustomMessage() {
     });
 }
 export async function suggestCommitMessage(options) {
+    // Ensure git diff does not print to console
     try {
-        let diff = execSync("git diff", { encoding: "utf-8" }).trim();
+        let diff = execSync("git diff", { encoding: "utf-8", stdio: "pipe" }).trim();
         if (!diff) {
-            diff = execSync("git diff --cached", { encoding: "utf-8" }).trim();
+            diff = execSync("git diff --cached", { encoding: "utf-8", stdio: "pipe" }).trim();
         }
         if (!diff) {
             console.log('⚠️  No staged changes to suggest a message for.');
             return;
         }
+        if (options.changelog) {
+            let entryFinalized = false;
+            while (!entryFinalized) {
+                const changelogEntry = await generateChangelogEntry(diff);
+                if (!changelogEntry) {
+                    console.log("ℹ️ No changelog entry generated.");
+                    break;
+                }
+                const userChoice = await askChangelogApproval(changelogEntry);
+                if (userChoice === 'yes') {
+                    const changelogPath = await updateChangelogFile(changelogEntry);
+                    execSync(`git add "${changelogPath}"`);
+                    console.log("✅ CHANGELOG.md staged.");
+                    entryFinalized = true;
+                }
+                else if (userChoice === 'redo') {
+                    console.log("🔁 Regenerating changelog entry...");
+                    continue; // Loop again and regenerate
+                }
+                else {
+                    console.log("❌ Skipped changelog update.");
+                    entryFinalized = true;
+                }
+            }
+        }
+        // Continue with commit suggestions
         const response = await commitSuggesterModule.run({ content: diff });
         const suggestions = response.suggestions || [];
         if (!suggestions.length) {
-            console.log('⚠️  No commit suggestions generated.');
+            console.log('⚠️ No commit suggestions generated.');
             return;
         }
-        // Show-only mode
-        if (!options.commit) {
-            console.log('\n💡 AI-suggested commit messages:\n');
-            suggestions.slice(0, 3).forEach((msg, i) => {
-                console.log(`${i + 1}) ${msg}`);
-            });
-            process.exit(0); // ensure clean exit
-        }
-        // Commit mode with selection
         let message = null;
         while (message === null) {
             const choice = await askUserToChoose(suggestions);

package/dist/index.js

@@ -11,7 +11,7 @@ import { handleRefactor } from "./commands/RefactorCmd.js";
 import { generateTests } from "./commands/TestGenCmd.js";
 import { bootstrap } from './modelSetup.js';
 import { summarizeFile } from "./commands/SummaryCmd.js";
-import { handleChangelogUpdate } from './commands/ChangeLogUpdateCmd.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';
@@ -25,7 +25,15 @@ const cmd = new Command('scai')
     .version(version)
     .option('--model <model>', 'Set the model to use (e.g., codellama:34b)')
     .option('--lang <lang>', 'Set the target language (ts, java, rust)');
-// 🚀 Init command
+function defineSuggCommand(cmd) {
+    cmd
+        .command('sugg')
+        .description('Suggest a commit message from staged changes')
+        .option('-c, --commit', 'Automatically commit with suggested message')
+        .option('-l, --changelog', 'Generate and optionally stage a changelog entry')
+        .action((options) => suggestCommitMessage(options));
+}
+// 🔧 Main command group
 cmd
     .command('init')
     .description('Initialize the model and download required models')
@@ -33,19 +41,12 @@ cmd
     await bootstrap();
     console.log('✅ Model initialization completed!');
 });
-cmd
-    .command('sugg')
-    .description('Suggest a commit message from staged changes')
-    .option('-c, --commit', 'Automatically commit with suggested message')
-    .action(suggestCommitMessage);
+// Register top-level `sugg` command
+defineSuggCommand(cmd);
 // 🔧 Group: Git-related commands
 const git = cmd.command('git').description('Git utilities');
-// The sugg command under the 'git' group
-git
-    .command('sugg')
-    .description('Suggest a commit message from staged changes')
-    .option('-c, --commit', 'Automatically commit with suggested message')
-    .action(suggestCommitMessage);
+// Register `sugg` under `git` group
+defineSuggCommand(git);
 // 🛠️ Group: `gen` commands for content generation
 const gen = cmd.command('gen').description('Generate code-related output');
 gen
@@ -57,7 +58,7 @@ gen
     .command('changelog')
     .description('Update or create the CHANGELOG.md based on current Git diff')
     .action(async () => {
-    await handleChangelogUpdate();
+    await handleStandaloneChangelogUpdate();
 });
 gen
     .command('summ [file]')

package/dist/pipeline/modules/changeLogModule.js

@@ -6,30 +6,42 @@ export const changelogModule = {
     async run(input) {
         const model = Config.getModel();
         const prompt = `
-You're an experienced changelog writer. Based on this Git diff, write a markdown bullet-point entry suitable for CHANGELOG.md:
+Using the Git diff below, return **only meaningful user-facing changes** as clean markdown bullet points.
+
+Analyze the intent of each change and summarize it in plain English — do not copy code or include explanations.
+
+ONLY return the bullet points!
+
+If no meaningful changes are present, return the text: "NO UPDATE".
 
 --- DIFF START ---
 ${input.content}
 --- DIFF END ---
-
-✅ If the changes are significant, return a changelog entry.
-❌ If not, return ONLY: "NO UPDATE".
-    `.trim();
+`.trim();
         const response = await generate({ content: prompt }, model);
-        const summary = response?.summary?.trim();
-        if (!summary || summary === 'NO UPDATE') {
-            // Return an empty summary and empty suggestions if there is no update.
-            return { content: response.content,
-                summary,
+        // Check if we received a meaningful result or "NO UPDATE"
+        const content = response?.content?.trim();
+        if (content === 'NO UPDATE') {
+            console.log("⚠️ No meaningful updates found. Returning 'NO UPDATE'.");
+            return {
+                content: response.content,
+                summary: 'NO UPDATE',
                 suggestions: response?.suggestions ?? [],
-                filepath: input.filepath };
+                filepath: input.filepath,
+            };
         }
-        // Return the actual changelog summary and any suggestions
+        // Split the content into lines
+        const lines = content?.split('\n').map(line => line.trim()) ?? [];
+        // Filter out non-bullet lines (now including the '•' symbol)
+        const bulletLines = lines.filter(line => /^([*-+•]|\d+\.)\s/.test(line));
+        // Join the filtered lines into the final changelog entry
+        const filtered = bulletLines.join('\n');
+        // Return the processed content and filtered changelog
         return {
             content: response.content,
-            summary,
+            summary: filtered,
             suggestions: response?.suggestions ?? [],
             filepath: input.filepath,
         };
-    },
+    }
 };

package/dist/pipeline/runModulePipeline.js

@@ -1,7 +1,7 @@
 export async function runModulePipeline(modules, input) {
     let current = input;
     // Add flag or condition for logging (optional)
-    const isDebug = true;
+    const isDebug = false;
     if (isDebug) {
         console.log('Input: ', input);
     }

package/dist/utils/changeLogPrompt.js

@@ -0,0 +1,30 @@
+// src/utils/changelogPrompt.ts
+import readline from 'readline';
+export async function askChangelogApproval(entry) {
+    return new Promise((resolve) => {
+        console.log('\n📜 Proposed changelog entry:\n');
+        console.log(entry);
+        console.log('\n---');
+        console.log('1) ✅ Accept and stage');
+        console.log('2) 🔁 Regenerate');
+        console.log('3) ❌ Skip changelog');
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question('\n👉 Choose an option [1-3]: ', (answer) => {
+            rl.close();
+            switch (answer.trim()) {
+                case '1':
+                    resolve('yes');
+                    break;
+                case '2':
+                    resolve('redo');
+                    break;
+                default:
+                    resolve('no');
+                    break;
+            }
+        });
+    });
+}

package/dist/utils/removeIgnoredFiles.js

@@ -2,7 +2,7 @@ import Database from 'better-sqlite3';
 import path from 'path';
 import os from 'os';
 import { IGNORED_EXTENSIONS } from '../config/IgnoredExtensions.js';
-import { specificFileExceptions } from './specificFileExceptions.js';
+import { specificFileExceptions } from '../config/specificFileExceptions.js';
 // THIS FILE IS MEANT TO BE RUN AS A NODE JS SCRIPT. node dist/src/utilsremoveIgnoredFiles.js
 // It removes wrongly indexed files that don't add value to the model. 
 const DB_PATH = path.join(os.homedir(), '.scai', 'db.sqlite');

package/dist/utils/shouldIgnoreFiles.js

@@ -1,6 +1,6 @@
 import path from 'path';
 import { IGNORED_EXTENSIONS } from '../config/IgnoredExtensions.js';
-import { specificFileExceptions } from '../utils/specificFileExceptions.js';
+import { specificFileExceptions } from '../config/specificFileExceptions.js';
 export function shouldIgnoreFile(filePath) {
     // Get file extension
     const ext = path.extname(filePath).toLowerCase();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scai",
-  "version": "0.1.32",
+  "version": "0.1.33",
   "type": "module",
   "bin": {
     "scai": "./dist/index.js"
@@ -21,7 +21,7 @@
     "llm"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "rm -rfd dist && tsc && git add .",
     "start": "node dist/index.js"
   },
   "dependencies": {