@nolrm/contextkit 0.8.4 → 0.9.3

package/README.md

@@ -138,15 +138,29 @@ ck ai "create checkout flow for customer"
 
 ---
 
-## Git Hooks
+## Git Hooks & Quality Gates
 
-ContextKit can optionally install Git hooks during `ck install`:
+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** | Runs tests, linting, and type checks before pushing |
+| **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:

package/lib/commands/install.js

@@ -178,20 +178,21 @@ class InstallCommand {
       return { prePush: false, commitMsg: false };
     }
 
-    if (!await fs.pathExists('package.json')) {
-      console.log(chalk.yellow('⚠️  Skipping Git hooks setup (no package.json found)'));
+    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('');
 
     // Ask about pre-push hook
-    console.log(chalk.bold('Pre-push hook'));
-    console.log(chalk.dim('Runs tests, linting, and type checks before pushing.'));
+    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([
       {

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, 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, hookChoices);
+      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, hookChoices = { prePush: true, commitMsg: true }) {
+  async addHooks(hookChoices = { prePush: true, commitMsg: true }) {
     // Backup existing hooks
     await this.backupExistingHooks();
 
@@ -164,38 +46,66 @@ fi
 
     // Add selected hooks
     if (hookChoices.prePush) {
-      await this.addHook(packageManager, 'pre-push', '.contextkit/hooks/pre-push.sh');
+      await this.addNativeHook('pre-push', '.contextkit/hooks/pre-push.sh');
     }
     if (hookChoices.commitMsg) {
-      await this.addHook(packageManager, 'commit-msg', '.contextkit/hooks/commit-msg.sh');
+      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}`));
@@ -203,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nolrm/contextkit",
-  "version": "0.8.4",
+  "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": {