devsplain 2.2.1 → 2.2.2

package/bin/cli.js

@@ -10,7 +10,7 @@ const { execSync } = require('child_process');
 let rl;
 let askQuestion;
 
-// Determines whether the current Git repository has uncommitted changes [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 whether a given 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 within a given list 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;
 }
 
-// Inserts or removes comments from code based on the specified mode [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';
@@ -717,7 +717,7 @@ function spliceComments(data, comments, mode = 'default', ext = '') {
     return annotated.map(line => line.text).join(lineEnding);
 }
 
-// Runs the command-line interface for the application [ds]
+// Runs the CLI interface for the application [ds]
 async function runCLI() {
     rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     askQuestion = (query) => new Promise((resolve) => rl.question(query, resolve));
@@ -744,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
 `);
@@ -767,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) {

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.1",
+  "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",