@nolrm/contextkit 0.8.2 → 0.9.3

package/README.md

@@ -138,6 +138,51 @@ ck ai "create checkout flow for customer"
 
 ---
 
+## Git Hooks & Quality Gates
+
+ContextKit can optionally install native Git hooks (`.git/hooks/`) during `ck install`. No external dependencies like Husky required — works in any git repo, not just Node.js projects.
+
+| Hook | What it does |
+|------|-------------|
+| **pre-push** | **Quality Gates** — auto-detects your project framework and runs the appropriate checks |
+| **commit-msg** | Enforces [Conventional Commits](https://www.conventionalcommits.org/) format |
+
+### Framework-Aware Quality Gates
+
+The pre-push hook detects your project type and runs the right quality checks automatically. All gates skip gracefully when tools aren't installed.
+
+| Framework | Checks |
+|-----------|--------|
+| **Node.js** | TypeScript, ESLint, Prettier, build, test (auto-detects npm/yarn/pnpm/bun) |
+| **Python** | ruff/flake8, mypy, black/ruff format, pytest |
+| **Rust** | cargo check, clippy, cargo test |
+| **Go** | go vet, golangci-lint, go test |
+| **PHP** | PHPStan, PHPUnit |
+| **Ruby** | RuboCop, RSpec/rake test |
+| **Java** | Maven verify / Gradle check |
+
+### Commit Message Format
+
+When the `commit-msg` hook is enabled, all commits must follow this format:
+
+```
+<type>(<scope>): <description>
+```
+
+**Types:** `feat`, `fix`, `docs`, `style`, `refactor`, `test`, `chore`
+
+**Examples:**
+```bash
+git commit -m "feat(auth): add login page"
+git commit -m "fix: resolve null pointer in checkout"
+git commit -m "docs: update API reference"
+git commit -m "test(cart): add edge case coverage"
+```
+
+Hooks are optional and can be skipped with `ck install --no-hooks`.
+
+---
+
 ## Key Features
 
 - 🧠 **Context Engineering** - Structured MD files your AI reads automatically

package/lib/commands/install.js

@@ -101,24 +101,26 @@ class InstallCommand {
     await this.downloadFiles(projectType, options, detectedTools);
 
     // Ask about Git hooks
-    let installHooks = true;
+    let hookChoices = { prePush: true, commitMsg: true };
     if (!options.nonInteractive && !options.noHooks) {
-      installHooks = await this.promptGitHooks();
+      hookChoices = await this.promptGitHooks();
+    } else if (options.noHooks) {
+      hookChoices = { prePush: false, commitMsg: false };
     }
 
     // Install Git hooks if requested
-    if (installHooks) {
-      await this.gitHooksManager.installHooks(packageManager);
+    if (hookChoices.prePush || hookChoices.commitMsg) {
+      await this.gitHooksManager.installHooks(packageManager, hookChoices);
     }
 
     // Create configuration
-    await this.createConfiguration(projectType, installHooks);
+    await this.createConfiguration(projectType, hookChoices);
 
     // Create status tracking
-    await this.createStatusFile(projectType, packageManager, installHooks);
+    await this.createStatusFile(projectType, packageManager, hookChoices);
 
     // Success message
-    this.showSuccessMessage(installHooks, detectedTools, projectType, packageManager);
+    this.showSuccessMessage(hookChoices, detectedTools, projectType, packageManager);
   }
 
   async installPlatformIntegration(platform) {
@@ -173,41 +175,71 @@ class InstallCommand {
     // Check for non-interactive mode
     if (process.env.CI === 'true' || process.env.NON_INTERACTIVE === 'true') {
       console.log(chalk.yellow('🤖 Non-interactive mode detected, skipping Git hooks'));
-      return false;
+      return { prePush: false, commitMsg: false };
     }
 
-    if (!await fs.pathExists('package.json')) {
-      console.log(chalk.yellow('⚠️  Skipping Git hooks setup (no package.json found)'));
-      return false;
+    if (!await fs.pathExists('.git')) {
+      console.log(chalk.yellow('⚠️  Skipping Git hooks setup (not a git repository)'));
+      return { prePush: false, commitMsg: false };
     }
 
     console.log('');
     console.log('──────────────────────────────────────────────');
-    console.log(chalk.blue('⚙️  Git Hooks Setup'));
+    console.log(chalk.blue('⚙️  Quality Gates — Git Hooks'));
     console.log('──────────────────────────────────────────────');
-    console.log('ContextKit can install **pre-push** and **commit-msg** hooks');
-    console.log('to automatically run tests, linting, and type checks before pushing.');
     console.log('');
+
+    // Ask about pre-push hook
+    console.log(chalk.bold('Pre-push Quality Gates'));
+    console.log(chalk.dim('Auto-detects your framework (Node, Python, Rust, Go, etc.)'));
+    console.log(chalk.dim('and runs the right checks before pushing.'));
+    console.log('');
+    const { prePush } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'prePush',
+        message: 'Enable pre-push hook? (runs quality checks before push)',
+        default: false
+      }
+    ]);
+
+    if (prePush) {
+      console.log(chalk.green('  ✅ Pre-push hook enabled'));
+    } else {
+      console.log(chalk.yellow('  ⏭️  Skipping pre-push hook'));
+    }
     console.log('');
 
-    const { installHooks } = await inquirer.prompt([
+    // Ask about commit-msg hook
+    console.log(chalk.bold('Commit message hook'));
+    console.log(chalk.dim('Enforces conventional commit format:'));
+    console.log(chalk.dim('  <type>(<scope>): <description>'));
+    console.log(chalk.dim('  types: feat, fix, docs, style, refactor, test, chore'));
+    console.log(chalk.dim('  example: feat(auth): add login page'));
+    console.log('');
+    const { commitMsg } = await inquirer.prompt([
       {
         type: 'confirm',
-        name: 'installHooks',
-        message: 'Do you want to enable Git hooks?',
+        name: 'commitMsg',
+        message: 'Enable commit-msg hook? (enforces conventional commit format)',
         default: false
       }
     ]);
 
-    if (installHooks) {
-      console.log(chalk.green('✅ Git hooks enabled'));
+    if (commitMsg) {
+      console.log(chalk.green('  ✅ Commit message hook enabled'));
+      console.log(chalk.blue('  💡 Commits must use: <type>(scope): description'));
     } else {
-      console.log(chalk.yellow('⏭️  Skipping Git hooks for now'));
-      console.log(chalk.blue('💡 You can enable them anytime with: `ck update --hooks`'));
+      console.log(chalk.yellow('  ⏭️  Skipping commit message hook'));
     }
     console.log('');
 
-    return installHooks;
+    if (!prePush && !commitMsg) {
+      console.log(chalk.blue('💡 You can enable hooks anytime with: `ck update --hooks`'));
+      console.log('');
+    }
+
+    return { prePush, commitMsg };
   }
 
   async createDirectoryStructure() {
@@ -751,9 +783,9 @@ esac
     console.log(chalk.green('✅ CLI helpers installed'));
   }
 
-  async createConfiguration(projectType, gitHooksEnabled) {
+  async createConfiguration(projectType, hookChoices) {
     const projectName = path.basename(process.cwd());
-    
+
     const config = {
       version: '1.0.0',
       project_name: projectName,
@@ -764,7 +796,8 @@ esac
         code_review: true,
         linting: true,
         type_safety: true,
-        git_hooks: gitHooksEnabled
+        pre_push_hook: hookChoices.prePush,
+        commit_msg_hook: hookChoices.commitMsg
       },
       paths: {
         components: 'src/components',
@@ -830,7 +863,8 @@ features:
   code_review: ${config.features.code_review}
   linting: ${config.features.linting}
   type_safety: ${config.features.type_safety}
-  git_hooks: ${config.features.git_hooks}
+  pre_push_hook: ${config.features.pre_push_hook}
+  commit_msg_hook: ${config.features.commit_msg_hook}
 
 # Paths (customize for your project)
 paths:
@@ -857,12 +891,13 @@ metadata:
     );
   }
 
-  async createStatusFile(projectType, packageManager, gitHooksEnabled) {
+  async createStatusFile(projectType, packageManager, hookChoices) {
     try {
       const status = this.statusManager.getDefaultStatus();
       status.project_type = projectType;
       status.package_manager = packageManager;
-      status.features.git_hooks = gitHooksEnabled;
+      status.features.pre_push_hook = hookChoices.prePush;
+      status.features.commit_msg_hook = hookChoices.commitMsg;
       
       await this.statusManager.saveStatus(status);
       console.log(chalk.green('✅ Status tracking initialized'));
@@ -1378,7 +1413,7 @@ enforcement:
     console.log(chalk.green('✅ Policy file created'));
   }
 
-  showSuccessMessage(gitHooksEnabled, detectedTools = {}, projectType = '', packageManager = '') {
+  showSuccessMessage(hookChoices, detectedTools = {}, projectType = '', packageManager = '') {
     console.log('');
     console.log(chalk.green('🎉 ContextKit v1.0.0 successfully installed!'));
     console.log('');

package/lib/commands/status.js

@@ -48,7 +48,8 @@ class StatusCommand {
       console.log('');
       
       console.log(chalk.blue('✅ Features:'));
-      console.log(`   Git Hooks: ${status.features.git_hooks ? '✅' : '❌'}`);
+      console.log(`   Pre-push hook: ${status.features.pre_push_hook ? '✅' : '❌'}`);
+      console.log(`   Commit-msg hook: ${status.features.commit_msg_hook ? '✅' : '❌'}`);
       console.log(`   Standards: ${status.features.standards ? '✅' : '❌'}`);
       console.log(`   Templates: ${status.features.templates ? '✅' : '❌'}`);
       console.log('');
@@ -121,8 +122,15 @@ class StatusCommand {
         config.features = config.features || {};
         config.features.type_safety = trimmed.split('type_safety:')[1].trim() === 'true';
       } else if (trimmed.startsWith('git_hooks:')) {
+        // Legacy single-flag compat
         config.features = config.features || {};
         config.features.git_hooks = trimmed.split('git_hooks:')[1].trim() === 'true';
+      } else if (trimmed.startsWith('pre_push_hook:')) {
+        config.features = config.features || {};
+        config.features.pre_push_hook = trimmed.split('pre_push_hook:')[1].trim() === 'true';
+      } else if (trimmed.startsWith('commit_msg_hook:')) {
+        config.features = config.features || {};
+        config.features.commit_msg_hook = trimmed.split('commit_msg_hook:')[1].trim() === 'true';
       }
     }
 

package/lib/commands/update.js

@@ -59,8 +59,12 @@ class UpdateCommand {
       await this.restoreUserConfig(config);
 
       // Update Git hooks if they were enabled
-      if (config.features?.git_hooks) {
-        await this.gitHooksManager.installHooks(packageManager);
+      const hookChoices = {
+        prePush: config.features?.pre_push_hook || config.features?.git_hooks || false,
+        commitMsg: config.features?.commit_msg_hook || config.features?.git_hooks || false
+      };
+      if (hookChoices.prePush || hookChoices.commitMsg) {
+        await this.gitHooksManager.installHooks(packageManager, hookChoices);
       }
 
       // Refresh installed platform integrations
@@ -176,8 +180,15 @@ class UpdateCommand {
         config.features = config.features || {};
         config.features.type_safety = trimmed.split('type_safety:')[1].trim() === 'true';
       } else if (trimmed.startsWith('git_hooks:')) {
+        // Legacy single-flag compat
         config.features = config.features || {};
         config.features.git_hooks = trimmed.split('git_hooks:')[1].trim() === 'true';
+      } else if (trimmed.startsWith('pre_push_hook:')) {
+        config.features = config.features || {};
+        config.features.pre_push_hook = trimmed.split('pre_push_hook:')[1].trim() === 'true';
+      } else if (trimmed.startsWith('commit_msg_hook:')) {
+        config.features = config.features || {};
+        config.features.commit_msg_hook = trimmed.split('commit_msg_hook:')[1].trim() === 'true';
       }
     }
 
@@ -294,7 +305,8 @@ features:
   code_review: ${config.features?.code_review || true}
   linting: ${config.features?.linting || true}
   type_safety: ${config.features?.type_safety || true}
-  git_hooks: ${config.features?.git_hooks || false}
+  pre_push_hook: ${config.features?.pre_push_hook || config.features?.git_hooks || false}
+  commit_msg_hook: ${config.features?.commit_msg_hook || config.features?.git_hooks || false}
 
 # Paths (customize for your project)
 paths:

package/lib/utils/git-hooks.js

@@ -1,30 +1,26 @@
-const { execSync } = require('child_process');
 const fs = require('fs-extra');
 const chalk = require('chalk');
 
 class GitHooksManager {
   constructor() {
-    this.hooksDir = '.husky';
+    this.hooksDir = '.git/hooks';
   }
 
-  async installHooks(packageManager) {
+  async installHooks(packageManager, hookChoices = { prePush: true, commitMsg: true }) {
     console.log(chalk.yellow('🪝 Setting up Git hooks...'));
 
-    // Check if Node.js is available
-    if (!this.checkCommandExists('node')) {
-      console.log(chalk.yellow('⚠️  Node.js not found, skipping Git hooks setup'));
+    // Check if this is a git repo
+    if (!fs.existsSync('.git')) {
+      console.log(chalk.yellow('⚠️  Not a git repository, skipping Git hooks setup'));
       return;
     }
 
     try {
-      // Install Husky based on package manager
-      await this.installHusky(packageManager);
-
-      // Initialize Husky
-      await this.initializeHusky(packageManager);
+      // Clean up legacy Husky directory if present
+      await this.cleanupLegacyHusky();
 
       // Add hooks
-      await this.addHooks(packageManager);
+      await this.addHooks(hookChoices);
 
       console.log(chalk.green('✅ Git hooks setup complete'));
 
@@ -34,121 +30,7 @@ class GitHooksManager {
     }
   }
 
-  async installHusky(packageManager) {
-    const huskyInstalled = await this.checkHuskyInstalled(packageManager);
-    
-    if (!huskyInstalled) {
-      console.log(chalk.blue(`📦 Installing Husky with ${packageManager}...`));
-      
-      try {
-        switch (packageManager) {
-          case 'yarn':
-            execSync('yarn add --dev husky', { stdio: 'inherit' });
-            break;
-          case 'pnpm':
-            execSync('pnpm add --save-dev husky', { stdio: 'inherit' });
-            break;
-          case 'npm':
-          default:
-            execSync('npm install --save-dev husky', { stdio: 'inherit' });
-            break;
-        }
-        console.log(chalk.green(`✅ Husky installed with ${packageManager}`));
-      } catch (error) {
-        console.log(chalk.yellow(`⚠️  Failed to install Husky with ${packageManager}, trying fallback...`));
-        // Fallback to npm if the detected package manager fails
-        if (packageManager !== 'npm') {
-          try {
-            execSync('npm install --save-dev husky', { stdio: 'inherit' });
-            console.log(chalk.green('✅ Husky installed with npm (fallback)'));
-          } catch (fallbackError) {
-            console.log(chalk.red('❌ Failed to install Husky with any package manager'));
-            throw new Error(`Failed to install Husky: ${fallbackError.message}`);
-          }
-        } else {
-          throw error;
-        }
-      }
-    } else {
-      console.log(chalk.green('✅ Husky already installed'));
-    }
-  }
-
-  async checkHuskyInstalled(packageManager) {
-    try {
-      // Check if husky is in package.json dependencies
-      const packageJson = await fs.readJson('package.json').catch(() => ({}));
-      const allDeps = {
-        ...packageJson.dependencies,
-        ...packageJson.devDependencies,
-        ...packageJson.peerDependencies
-      };
-      
-      if (allDeps.husky) {
-        return true;
-      }
-      
-      // Fallback: try package manager specific commands
-      switch (packageManager) {
-        case 'yarn':
-          execSync('yarn list --pattern husky', { stdio: 'pipe' });
-          return true;
-        case 'pnpm':
-          execSync('pnpm list husky', { stdio: 'pipe' });
-          return true;
-        case 'npm':
-        default:
-          execSync('npm list husky', { stdio: 'pipe' });
-          return true;
-      }
-    } catch (error) {
-      return false;
-    }
-  }
-
-  async initializeHusky(packageManager) {
-    // Modern Husky doesn't need explicit initialization
-    // Just ensure .husky directory exists
-    await fs.ensureDir(this.hooksDir);
-    
-    // Create husky.sh if it doesn't exist (for compatibility)
-    const huskyShPath = `${this.hooksDir}/_/husky.sh`;
-    if (!await fs.pathExists(huskyShPath)) {
-      await fs.ensureDir(`${this.hooksDir}/_`);
-      const huskyShContent = `#!/usr/bin/env sh
-if [ -z "$husky_skip_init" ]; then
-  debug () {
-    if [ "$HUSKY_DEBUG" = "1" ]; then
-      echo "husky (debug) - $1"
-    fi
-  }
-
-  readonly hook_name="$(basename -- "$0")"
-  debug "starting $hook_name..."
-
-  if [ "$HUSKY" = "0" ]; then
-    debug "HUSKY env variable is set to 0, skipping hook"
-    exit 0
-  fi
-
-  if [ -f ~/.huskyrc ]; then
-    debug "sourcing ~/.huskyrc"
-    . ~/.huskyrc
-  fi
-
-  readonly husky_skip_init=1
-  export husky_skip_init
-  sh -e "$0" "$@"
-fi
-`;
-      await fs.writeFile(huskyShPath, huskyShContent);
-      await fs.chmod(huskyShPath, '755');
-    }
-    
-    console.log(chalk.green('✅ Husky initialized'));
-  }
-
-  async addHooks(packageManager) {
+  async addHooks(hookChoices = { prePush: true, commitMsg: true }) {
     // Backup existing hooks
     await this.backupExistingHooks();
 
@@ -162,42 +44,68 @@ fi
       }
     }
 
-    // Add new hooks
-    const hooks = [
-      { name: 'pre-push', script: '.contextkit/hooks/pre-push.sh' },
-      { name: 'commit-msg', script: '.contextkit/hooks/commit-msg.sh' }
-    ];
-
-    for (const hook of hooks) {
-      await this.addHook(packageManager, hook.name, hook.script);
+    // Add selected hooks
+    if (hookChoices.prePush) {
+      await this.addNativeHook('pre-push', '.contextkit/hooks/pre-push.sh');
+    }
+    if (hookChoices.commitMsg) {
+      await this.addNativeHook('commit-msg', '.contextkit/hooks/commit-msg.sh');
     }
   }
 
-  async addHook(packageManager, hookName, scriptPath) {
+  async addNativeHook(hookName, scriptPath) {
     const hookPath = `${this.hooksDir}/${hookName}`;
-    
-    // Ensure .husky directory exists
+
+    // Ensure .git/hooks directory exists
     await fs.ensureDir(this.hooksDir);
-    
-    // Create hook file directly (modern Husky approach)
-    const hookContent = `#!/usr/bin/env sh
-. "$(dirname -- "$0")/_/husky.sh"
 
+    // Write hook directly — no Husky, just a shebang + delegation
+    const hookContent = `#!/usr/bin/env sh
+# ContextKit managed hook — do not edit
 ${scriptPath} "$@"
 `;
-    
+
     await fs.writeFile(hookPath, hookContent);
     await fs.chmod(hookPath, '755');
-    
+
     console.log(chalk.green(`✅ Created hook: ${hookName}`));
   }
 
+  async cleanupLegacyHusky() {
+    if (!fs.existsSync('.husky')) return;
+
+    // Check if the .husky dir contains ContextKit/Vibe Kit markers
+    const huskyHooks = ['pre-push', 'commit-msg', 'pre-commit'];
+    let hasContextKitHooks = false;
+
+    for (const hook of huskyHooks) {
+      const hookPath = `.husky/${hook}`;
+      if (fs.existsSync(hookPath)) {
+        const content = await fs.readFile(hookPath, 'utf8');
+        if (content.includes('.contextkit/') || content.includes('.vibe-kit/')) {
+          hasContextKitHooks = true;
+          break;
+        }
+      }
+    }
+
+    if (hasContextKitHooks) {
+      await fs.remove('.husky');
+      console.log(chalk.yellow('🧹 Removed legacy .husky/ directory (now using native .git/hooks/)'));
+      console.log(chalk.dim('   💡 You can also run: npm uninstall husky'));
+    }
+  }
+
   async backupExistingHooks() {
     const hooks = ['pre-push', 'commit-msg'];
 
     for (const hook of hooks) {
       const hookPath = `${this.hooksDir}/${hook}`;
       if (fs.existsSync(hookPath)) {
+        // Don't back up our own hooks
+        const content = await fs.readFile(hookPath, 'utf8');
+        if (content.includes('ContextKit managed hook')) continue;
+
         const backupPath = `${hookPath}.backup`;
         await fs.copy(hookPath, backupPath);
         console.log(chalk.yellow(`📦 Backed up existing hook: ${hook}`));
@@ -205,24 +113,15 @@ ${scriptPath} "$@"
     }
   }
 
-  checkCommandExists(command) {
-    try {
-      execSync(`which ${command}`, { stdio: 'pipe' });
-      return true;
-    } catch (error) {
-      return false;
-    }
-  }
-
   async uninstallHooks() {
     console.log(chalk.yellow('🪝 Removing Git hooks...'));
-    
+
     const hooks = ['pre-push', 'commit-msg'];
 
     for (const hook of hooks) {
       const hookPath = `${this.hooksDir}/${hook}`;
       const backupPath = `${hookPath}.backup`;
-      
+
       if (fs.existsSync(backupPath)) {
         await fs.move(backupPath, hookPath);
         console.log(chalk.green(`✅ Restored original hook: ${hook}`));

package/lib/utils/status-manager.js

@@ -31,7 +31,8 @@ class StatusManager {
         package_manager: null
       },
       features: {
-        git_hooks: false,
+        pre_push_hook: false,
+        commit_msg_hook: false,
         standards: true,
         templates: true
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nolrm/contextkit",
-  "version": "0.8.2",
+  "version": "0.9.3",
   "description": "ContextKit - Context Engineering for AI Development. Provide rich context to AI through structured MD files with standards, code guides, and documentation. Works with Cursor, Claude, Aider, VS Code Copilot, and more.",
   "main": "lib/index.js",
   "bin": {