devsplain 2.2.0 → 2.2.2

package/bin/cli.js

@@ -10,7 +10,7 @@ const { execSync } = require('child_process');
 let rl;
 let askQuestion;
 
-// Checks if the Git working tree is dirty [ds]
+// Checks if the Git repository is dirty [ds]
 function isGitDirty() {
     try {
         const gitDir = execSync('git rev-parse --is-inside-work-tree', { stdio: ['ignore', 'pipe', 'ignore'], encoding: 'utf8' }).trim();
@@ -23,7 +23,7 @@ function isGitDirty() {
     return false;
 }
 
-// Checks if a line of code is inside a string literal [ds]
+// Determines if a line is inside a string literal [ds]
 function isLineInsideString(lines, targetLineIndex, ext = '') {
     const isPython = ext.toLowerCase() === '.py';
     const isHTML = ['.html', '.vue', '.svelte'].includes(ext.toLowerCase());
@@ -236,7 +236,7 @@ function isLineInsideString(lines, targetLineIndex, ext = '') {
     return inBacktick || inTripleDouble || inTripleSingle || inSingle || inDouble || inCppRawString || inRegex;
 }
 
-// Analyzes comments in a given set of code lines [ds]
+// Analyzes comments in the given lines of code [ds]
 function analyzeComments(lines, ext = '') {
     const isPython = ext.toLowerCase() === '.py';
     const isHTML = ['.html', '.vue', '.svelte'].includes(ext.toLowerCase());
@@ -477,7 +477,7 @@ function analyzeComments(lines, ext = '') {
     return analysis;
 }
 
-// Splices comments into the given code data [ds]
+// Splices comments into the provided data [ds]
 function spliceComments(data, comments, mode = 'default', ext = '') {
     const hasCRLF = data.includes('\r\n');
     const lineEnding = hasCRLF ? '\r\n' : '\n';
@@ -530,7 +530,23 @@ function spliceComments(data, comments, mode = 'default', ext = '') {
                 if (lineAnalysis.isPureComment) {
                     finalDeletions.add(lineNum);
                 } else if (lineAnalysis.commentStartIndex !== -1) {
-                    annotated[i].text = lineStr.slice(0, lineAnalysis.commentStartIndex).trimEnd();
+                    const idx = lineAnalysis.commentStartIndex;
+                    const remainder = lineStr.slice(idx);
+                    let newText = lineStr.slice(0, idx).trimEnd();
+                    
+                    if (remainder.startsWith('/*')) {
+                        const endIdx = remainder.indexOf('*/');
+                        if (endIdx !== -1) {
+                            newText = lineStr.slice(0, idx) + remainder.slice(endIdx + 2);
+                        }
+                    } else if (remainder.startsWith('<!--')) {
+                        const endIdx = remainder.indexOf('-->');
+                        if (endIdx !== -1) {
+                            newText = lineStr.slice(0, idx) + remainder.slice(endIdx + 3);
+                        }
+                    }
+                    
+                    annotated[i].text = newText.trimEnd();
                 }
             } else if (mode === 'clean') {
                 const isDsBlockLine = dsBlocks.has(lineNum);
@@ -542,7 +558,23 @@ function spliceComments(data, comments, mode = 'default', ext = '') {
                     }
                 } else if (lineAnalysis.commentStartIndex !== -1) {
                     if (isDsBlockLine || hasDsInline) {
-                        annotated[i].text = lineStr.slice(0, lineAnalysis.commentStartIndex).trimEnd();
+                        const idx = lineAnalysis.commentStartIndex;
+                        const remainder = lineStr.slice(idx);
+                        let newText = lineStr.slice(0, idx).trimEnd();
+                        
+                        if (remainder.startsWith('/*')) {
+                            const endIdx = remainder.indexOf('*/');
+                            if (endIdx !== -1) {
+                                newText = lineStr.slice(0, idx) + remainder.slice(endIdx + 2);
+                            }
+                        } else if (remainder.startsWith('<!--')) {
+                            const endIdx = remainder.indexOf('-->');
+                            if (endIdx !== -1) {
+                                newText = lineStr.slice(0, idx) + remainder.slice(endIdx + 3);
+                            }
+                        }
+                        
+                        annotated[i].text = newText.trimEnd();
                     }
                 }
             }
@@ -643,7 +675,23 @@ function spliceComments(data, comments, mode = 'default', ext = '') {
                 const isDsBlockLine = dsBlocks.has(origIdx + 1);
                 const hasDsInline = originalLine.includes('[ds]');
                 if (mode === 'prune' || (mode === 'clean' && (hasDsInline || isDsBlockLine))) {
-                    const expectedStripped = originalLine.slice(0, lineAnalysis.commentStartIndex).trimEnd();
+                    const idx = lineAnalysis.commentStartIndex;
+                    const remainder = originalLine.slice(idx);
+                    let expectedStripped = originalLine.slice(0, idx).trimEnd();
+                    
+                    if (remainder.startsWith('/*')) {
+                        const endIdx = remainder.indexOf('*/');
+                        if (endIdx !== -1) {
+                            expectedStripped = originalLine.slice(0, idx) + remainder.slice(endIdx + 2);
+                        }
+                    } else if (remainder.startsWith('<!--')) {
+                        const endIdx = remainder.indexOf('-->');
+                        if (endIdx !== -1) {
+                            expectedStripped = originalLine.slice(0, idx) + remainder.slice(endIdx + 3);
+                        }
+                    }
+                    expectedStripped = expectedStripped.trimEnd();
+
                     if (text === expectedStripped) {
                         return true;
                     }
@@ -696,6 +744,7 @@ Options:
   --base-url <url>    Override base URL for custom APIs
   --config            Force run the configuration setup wizard
   --setup-hook        Install Git pre-commit and post-commit hooks in repository
+  --remove-hook       Remove devsplain-installed Git hooks from repository
   --help, -h          Show this help message
   --version, -v       Show version information
 `);
@@ -719,11 +768,18 @@ Options:
 
     if (args.includes('--setup-hook')) {
         rl.close();
-        const installHooks = require('./setup-hook.js');
+        const { installHooks } = require('./setup-hook.js');
         await installHooks();
         return;
     }
 
+    if (args.includes('--remove-hook')) {
+        rl.close();
+        const { removeHooks } = require('./setup-hook.js');
+        await removeHooks();
+        return;
+    }
+
     const getArgValue = (flag) => {
         const index = args.indexOf(flag);
         if (index !== -1 && index + 1 < args.length) {
@@ -823,7 +879,6 @@ Options:
         return false;
     }
 
-    // Processes a given file path, either a file or directory [ds]
     async function processPath(targetPath) {
         const stats = fs.statSync(targetPath);
 
@@ -881,7 +936,6 @@ Options:
                         fs.renameSync(tempPath, targetPath);
                         console.log(` Successfully saved ${targetPath}`);
                     } else {
-                        // Asks the user if they want to save the commented code to a file [ds]
                         console.log(` Skipped ${targetPath}`);
                     }
                 } else {
@@ -914,7 +968,6 @@ Options:
     rl.close();
 }
 
-// Starts the CLI application if this script is run directly [ds]
 if (require.main === module) {
     runCLI().catch(err => {
         console.error(err);

package/bin/setup-hook.js

@@ -3,7 +3,7 @@ const path = require('path');
 const { execSync } = require('child_process');
 const readline = require('readline');
 
-/** Installs Git hooks and configures commit settings [ds] */
+// Installs Git hooks for automatic comment generation [ds]
 async function installHooks() {
     try {
         const gitDir = execSync('git rev-parse --git-dir', { encoding: 'utf8' }).trim();
@@ -14,7 +14,7 @@ async function installHooks() {
         }
 
         let modeChoice = '1';
-        // Check if process is run in a TTY environment [ds]
+        // Prompt user for commenting mode if running in a TTY [ds]
         if (process.stdout.isTTY) {
             const rl = readline.createInterface({
                 input: process.stdin,
@@ -22,13 +22,13 @@ async function installHooks() {
             });
             const askQuestion = (query) => new Promise((resolve) => rl.question(query, resolve));
 
-            // Prompt user to select the default commenting mode [ds]
+            // Display commenting mode options to the user [ds]
             console.log('\nSelect default commenting mode for Git commits:');
             console.log('1. Balanced (mix of JSDoc and sparse inline comments)');
             console.log('2. Light (JSDoc block comments above functions only)');
             console.log('3. Full (aggressive inline commenting)');
             
-            // Validate user input for commenting mode [ds]
+            // Loop until a valid mode choice is selected [ds]
             while (true) {
                 const answer = (await askQuestion('Select (1-3, default: 1): ')).trim();
                 if (answer === '' || ['1', '2', '3'].includes(answer)) {
@@ -40,7 +40,7 @@ async function installHooks() {
             rl.close();
         }
 
-        // Determine mode arguments based on user choice [ds]
+        // Determine mode arguments based on user selection [ds]
         let modeArgs = '';
         if (modeChoice === '2') {
             modeArgs = ' --light';
@@ -48,7 +48,7 @@ async function installHooks() {
             modeArgs = ' --full';
         }
 
-        // Define the pre-commit hook script [ds]
+        // Create pre-commit hook script [ds]
         const preCommitHookPath = path.join(hooksDir, 'pre-commit');
         const preCommitContent = `#!/bin/sh
 # devsplain native pre-commit hook
@@ -57,63 +57,126 @@ if [ -f package.json ] && grep -q '"test"' package.json 2>/dev/null; then
   npm test || exit 1
 fi
 `;
-        // Write the pre-commit hook to the Git hooks directory [ds]
+        // Write pre-commit hook to file [ds]
         fs.writeFileSync(preCommitHookPath, preCommitContent);
         try {
             fs.chmodSync(preCommitHookPath, 0o755);
         } catch (err) {}
 
-        // Define the post-commit script path [ds]
+        // Path to post-commit script [ds]
         const postCommitScript = path.join(__dirname, 'post-commit.js').replace(/\\/g, '/');
 
-        // Define the post-commit hook script [ds]
+        // Create post-commit hook script [ds]
         const postCommitHookPath = path.join(hooksDir, 'post-commit');
         const postCommitContent = `#!/bin/sh
 # devsplain native post-commit hook
 echo "Auto-generating comments for files in the last commit..."
 node "${postCommitScript}"${modeArgs} || exit 1
 `;
+        // Write post-commit hook to file [ds]
         fs.writeFileSync(postCommitHookPath, postCommitContent);
         try {
             fs.chmodSync(postCommitHookPath, 0o755);
         } catch (err) {}
 
-        // Inform the user about the successful installation of the post-commit hook [ds]
+        // Log successful installation of post-commit hook [ds]
         console.log(`[devsplain] Git post-commit hook successfully installed at: ${postCommitHookPath}`);
 
-        // Check if a .devsplainignore file exists in the Git root directory [ds]
+        // Path to devsplain ignore file [ds]
         const ignorePath = path.join(gitRoot, '.devsplainignore');
+        const defaultIgnoreLines = [
+            'node_modules/', '.git/', 'dist/', 'build/', 'out/',
+            '.next/', '.nuxt/', '.svelte-kit/',
+            'venv/', 'env/', '.venv/',
+            '.vscode/', '.idea/', 'coverage/',
+            'tests/', '__tests__/', 'fixtures/'
+        ];
+// List of default patterns to ignore [ds]
+
+        const gitignorePath = path.join(gitRoot, '.gitignore');
+        let gitignoreLines = [];
+        if (fs.existsSync(gitignorePath)) {
+            const gitignoreContent = fs.readFileSync(gitignorePath, 'utf8');
+            gitignoreLines = gitignoreContent.split(/\r?\n/)
+                .map(l => l.trim())
+                .filter(l => l && !l.startsWith('#'));
+        }
+
+        // Check if .gitignore file exists [ds]
         if (!fs.existsSync(ignorePath)) {
-            const defaultIgnore = `node_modules/
-.git/
-dist/
-build/
-out/
-.next/
-.nuxt/
-.svelte-kit/
-venv/
-env/
-.venv/
-.vscode/
-.idea/
-coverage/
-tests/
-__tests__/
-fixtures/
-`;
-            fs.writeFileSync(ignorePath, defaultIgnore);
-            console.log(`[devsplain] Created default .devsplainignore file at: ${ignorePath}`);
+            const gitignoreOnly = gitignoreLines.filter(p => !defaultIgnoreLines.includes(p));
+            let content = defaultIgnoreLines.join('\n') + '\n';
+            if (gitignoreOnly.length > 0) {
+                content += '\n# From .gitignore\n' + gitignoreOnly.join('\n') + '\n';
+            }
+            fs.writeFileSync(ignorePath, content);
+            console.log(`[devsplain] Created .devsplainignore at: ${ignorePath}`);
+            if (gitignoreOnly.length > 0) {
+                console.log(`[devsplain] Merged ${gitignoreOnly.length} pattern(s) from .gitignore into .devsplainignore.`);
+            }
+        } else {
+            const existingContent = fs.readFileSync(ignorePath, 'utf8');
+            const existingLines = existingContent.split(/\r?\n/).map(l => l.trim()).filter(l => l && !l.startsWith('#'));
+            const newPatterns = gitignoreLines.filter(p => !existingLines.includes(p));
+            if (newPatterns.length > 0) {
+                const appendContent = '\n# From .gitignore\n' + newPatterns.join('\n') + '\n';
+                fs.appendFileSync(ignorePath, appendContent);
+                console.log(`[devsplain] Merged ${newPatterns.length} new pattern(s) from .gitignore into .devsplainignore.`);
+            } else if (gitignoreLines.length > 0) {
+                console.log('[devsplain] .devsplainignore is already up-to-date with .gitignore patterns.');
+            }
+        // Handle any errors during hook installation [ds]
         }
+
     } catch (e) {
         console.warn('Warning: Could not set up Git hooks (not inside a git repository or git command missing).');
         console.warn(e.message);
     }
 }
 
-// Check if the script is run as the main module [ds]
+// Removes Git hooks installed by devsplain [ds]
+async function removeHooks() {
+    try {
+        const gitDir = execSync('git rev-parse --git-dir', { encoding: 'utf8' }).trim();
+        const hooksDir = path.join(gitDir, 'hooks');
+        const hookSignatures = {
+            'pre-commit': '# devsplain native pre-commit hook',
+            'post-commit': '# devsplain native post-commit hook'
+        };
+
+        let removed = 0;
+        // Iterate through hook signatures to remove [ds]
+        for (const [hookName, signature] of Object.entries(hookSignatures)) {
+            const hookPath = path.join(hooksDir, hookName);
+            if (fs.existsSync(hookPath)) {
+                const content = fs.readFileSync(hookPath, 'utf8');
+                if (content.includes(signature)) {
+                    fs.unlinkSync(hookPath);
+                    console.log(`[devsplain] Removed ${hookName} hook at: ${hookPath}`);
+                    removed++;
+                } else {
+                    console.log(`[devsplain] Skipping ${hookName}: not installed by devsplain.`);
+                }
+            } else {
+                console.log(`[devsplain] No ${hookName} hook found at: ${hookPath}`);
+            }
+        }
+
+        // Log removal of hooks [ds]
+        if (removed > 0) {
+            console.log(`[devsplain] Successfully removed ${removed} hook(s).`);
+        } else {
+            console.log('[devsplain] No devsplain hooks were found to remove.');
+        }
+    } catch (e) {
+        console.warn('Warning: Could not remove Git hooks (not inside a git repository or git command missing).');
+        console.warn(e.message);
+    }
+}
+
+// Run installHooks if this script is executed directly [ds]
 if (require.main === module) {
     installHooks();
 }
-// Export the installHooks function for external use [ds]
-module.exports = installHooks;
+// Export installHooks and removeHooks functions [ds]
+module.exports = { installHooks, removeHooks };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devsplain",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "An agent-agnostic CLI tool that automatically adds JSDoc and inline comments to your code using free LLMs.",
   "author": "mwahaj36",
   "license": "MIT",