@nolrm/contextkit 0.7.3

package/lib/integrations/windsurf-integration.js

@@ -0,0 +1,88 @@
+const chalk = require('chalk');
+const BaseIntegration = require('./base-integration');
+
+class WindsurfIntegration extends BaseIntegration {
+  constructor() {
+    super();
+    this.name = 'windsurf';
+    this.displayName = 'Windsurf';
+    this.bridgeFiles = ['.windsurfrules'];
+    this.generatedFiles = ['.windsurf/rules/contextkit-standards.md'];
+    this.platformDir = '.windsurf/rules';
+  }
+
+  async install() {
+    await super.install();
+    // Remove old vibe-kit-named files
+    const fs = require('fs-extra');
+    const legacyFile = '.windsurf/rules/vibe-kit-standards.md';
+    if (await fs.pathExists(legacyFile)) {
+      await fs.remove(legacyFile);
+    }
+  }
+
+  async generateFiles() {
+    // Bridge file: .windsurfrules (auto-loaded by Windsurf)
+    const bridgeContent = `# Project Standards (ContextKit)
+
+This project uses [ContextKit](https://github.com/nolrm/contextkit) for AI development standards.
+
+${this.getStandardsBlock()}
+
+## Key Rules
+
+- Follow coding conventions in \`.contextkit/standards/code-style.md\`
+- Use numbered test cases as defined in \`.contextkit/standards/testing.md\`
+- Check \`.contextkit/standards/glossary.md\` for project-specific terminology
+- Reference \`.contextkit/templates/\` for code generation patterns`;
+
+    await this.writeBridgeFile('.windsurfrules', bridgeContent);
+
+    // Modular rules file
+    const standardsRule = `---
+description: ContextKit project standards
+alwaysApply: true
+---
+
+# ContextKit Standards
+
+This project uses ContextKit for structured development standards.
+
+## References
+
+- \`.contextkit/standards/code-style.md\` — Coding conventions
+- \`.contextkit/standards/testing.md\` — Testing patterns (numbered test cases required)
+- \`.contextkit/standards/architecture.md\` — Architecture patterns
+- \`.contextkit/standards/ai-guidelines.md\` — AI behavior rules
+- \`.contextkit/standards/glossary.md\` — Project terminology
+- \`.contextkit/product/mission-lite.md\` — Product context
+
+## Templates
+
+- \`.contextkit/templates/component.tsx\` — Component template
+- \`.contextkit/templates/test.tsx\` — Test template
+- \`.contextkit/templates/hook.ts\` — Custom hook template
+- \`.contextkit/templates/api.ts\` — API service template
+
+## Commands
+
+- \`.contextkit/commands/analyze.md\` — Analyze and customize standards
+- \`.contextkit/commands/create-component.md\` — Create components
+- \`.contextkit/commands/create-feature.md\` — Create features
+`;
+    await this.writeGeneratedFile('.windsurf/rules/contextkit-standards.md', standardsRule);
+  }
+
+  showUsage() {
+    console.log('');
+    console.log(chalk.bold('  Windsurf Usage:'));
+    console.log('    .windsurfrules is auto-loaded by Windsurf');
+    console.log('    .windsurf/rules/ provides additional context');
+    console.log('');
+    console.log(chalk.dim('  Files created:'));
+    console.log(chalk.dim('    .windsurfrules (bridge - auto-loaded)'));
+    console.log(chalk.dim('    .windsurf/rules/contextkit-standards.md (rules)'));
+  }
+}
+
+module.exports = WindsurfIntegration;

package/lib/utils/download.js

@@ -0,0 +1,50 @@
+const axios = require('axios');
+const fs = require('fs-extra');
+const path = require('path');
+
+class DownloadManager {
+  constructor() {
+    this.timeout = 30000; // 30 seconds
+    this.retries = 3;
+  }
+
+  async downloadFile(url, outputPath, retryCount = 0) {
+    try {
+      // Ensure directory exists
+      await fs.ensureDir(path.dirname(outputPath));
+
+      const response = await axios({
+        method: 'GET',
+        url: url,
+        responseType: 'stream',
+        timeout: this.timeout,
+        headers: {
+          'User-Agent': 'contextkit-cli/1.0.0'
+        }
+      });
+
+      const writer = fs.createWriteStream(outputPath);
+      response.data.pipe(writer);
+
+      return new Promise((resolve, reject) => {
+        writer.on('finish', resolve);
+        writer.on('error', reject);
+      });
+
+    } catch (error) {
+      if (retryCount < this.retries) {
+        console.log(`Retrying download (${retryCount + 1}/${this.retries})...`);
+        await new Promise(resolve => setTimeout(resolve, 1000 * (retryCount + 1)));
+        return this.downloadFile(url, outputPath, retryCount + 1);
+      }
+      throw new Error(`Failed to download ${url}: ${error.message}`);
+    }
+  }
+
+  async downloadMultiple(files) {
+    const promises = files.map(({ url, path }) => this.downloadFile(url, path));
+    return Promise.all(promises);
+  }
+}
+
+module.exports = DownloadManager;

package/lib/utils/git-hooks.js

@@ -0,0 +1,228 @@
+const { execSync } = require('child_process');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+
+class GitHooksManager {
+  constructor() {
+    this.hooksDir = '.husky';
+  }
+
+  async installHooks(packageManager) {
+    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'));
+      return;
+    }
+
+    try {
+      // Install Husky based on package manager
+      await this.installHusky(packageManager);
+
+      // Initialize Husky
+      await this.initializeHusky(packageManager);
+
+      // Add hooks
+      await this.addHooks(packageManager);
+
+      console.log(chalk.green('✅ Git hooks setup complete'));
+
+    } catch (error) {
+      console.log(chalk.red('❌ Git hooks setup failed:'), error.message);
+      throw error;
+    }
+  }
+
+  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) {
+    // Backup existing hooks
+    await this.backupExistingHooks();
+
+    // Add new hooks
+    const hooks = [
+      { name: 'pre-commit', script: '.contextkit/hooks/pre-commit.sh' },
+      { 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);
+    }
+  }
+
+  async addHook(packageManager, hookName, scriptPath) {
+    const hookPath = `${this.hooksDir}/${hookName}`;
+    
+    // Ensure .husky directory exists
+    await fs.ensureDir(this.hooksDir);
+    
+    // Create hook file directly (modern Husky approach)
+    const hookContent = `#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+${scriptPath}
+`;
+    
+    await fs.writeFile(hookPath, hookContent);
+    await fs.chmod(hookPath, '755');
+    
+    console.log(chalk.green(`✅ Created hook: ${hookName}`));
+  }
+
+  async backupExistingHooks() {
+    const hooks = ['pre-commit', 'pre-push', 'commit-msg'];
+    
+    for (const hook of hooks) {
+      const hookPath = `${this.hooksDir}/${hook}`;
+      if (fs.existsSync(hookPath)) {
+        const backupPath = `${hookPath}.backup`;
+        await fs.copy(hookPath, backupPath);
+        console.log(chalk.yellow(`📦 Backed up existing hook: ${hook}`));
+      }
+    }
+  }
+
+  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-commit', '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}`));
+      } else if (fs.existsSync(hookPath)) {
+        await fs.remove(hookPath);
+        console.log(chalk.green(`✅ Removed hook: ${hook}`));
+      }
+    }
+  }
+}
+
+module.exports = GitHooksManager;

package/lib/utils/project-detector.js

@@ -0,0 +1,110 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+class ProjectDetector {
+  constructor() {
+    this.projectRoot = process.cwd();
+  }
+
+  detectProjectType() {
+    if (fs.existsSync('package.json')) {
+      const packageJson = this.readPackageJson();
+      
+      // Detect framework
+      if (this.hasDependency(packageJson, 'react') || this.hasDependency(packageJson, '@types/react')) {
+        return this.detectReactVariant(packageJson);
+      } else if (this.hasDependency(packageJson, 'vue') || this.hasDependency(packageJson, '@vue')) {
+        return this.detectVueVariant(packageJson);
+      } else if (this.hasDependency(packageJson, '@angular/core')) {
+        return 'angular';
+      } else if (this.hasDependency(packageJson, 'next')) {
+        return 'nextjs';
+      } else if (this.hasDependency(packageJson, 'nuxt')) {
+        return 'nuxt';
+      } else if (this.hasDependency(packageJson, 'svelte')) {
+        return 'svelte';
+      } else {
+        return 'node';
+      }
+    } else if (fs.existsSync('requirements.txt') || fs.existsSync('pyproject.toml')) {
+      return 'python';
+    } else if (fs.existsSync('Cargo.toml')) {
+      return 'rust';
+    } else if (fs.existsSync('go.mod')) {
+      return 'go';
+    } else if (fs.existsSync('composer.json')) {
+      return 'php';
+    } else if (fs.existsSync('Gemfile')) {
+      return 'ruby';
+    } else if (fs.existsSync('pom.xml') || fs.existsSync('build.gradle')) {
+      return 'java';
+    }
+    
+    return 'generic';
+  }
+
+  detectReactVariant(packageJson) {
+    if (this.hasDependency(packageJson, 'vite')) {
+      return 'react-vite';
+    } else if (this.hasDependency(packageJson, 'webpack')) {
+      return 'react-webpack';
+    } else if (this.hasDependency(packageJson, 'rollup')) {
+      return 'react-rollup';
+    } else if (this.hasDependency(packageJson, 'next')) {
+      return 'nextjs';
+    }
+    return 'react';
+  }
+
+  detectVueVariant(packageJson) {
+    if (this.hasDependency(packageJson, 'vite')) {
+      return 'vue-vite';
+    } else if (this.hasDependency(packageJson, 'webpack')) {
+      return 'vue-webpack';
+    } else if (this.hasDependency(packageJson, 'nuxt')) {
+      return 'nuxt';
+    }
+    return 'vue';
+  }
+
+  detectPackageManager() {
+    if (fs.existsSync('yarn.lock')) {
+      return 'yarn';
+    } else if (fs.existsSync('pnpm-lock.yaml')) {
+      return 'pnpm';
+    } else if (fs.existsSync('package-lock.json')) {
+      return 'npm';
+    } else if (fs.existsSync('package.json')) {
+      return 'npm'; // Default to npm
+    }
+    return 'none';
+  }
+
+  hasDependency(packageJson, dependency) {
+    const deps = packageJson.dependencies || {};
+    const devDeps = packageJson.devDependencies || {};
+    return deps[dependency] || devDeps[dependency];
+  }
+
+  readPackageJson() {
+    try {
+      return JSON.parse(fs.readFileSync('package.json', 'utf8'));
+    } catch (error) {
+      return {};
+    }
+  }
+
+  isGitRepository() {
+    return fs.existsSync('.git');
+  }
+
+  getProjectName() {
+    if (fs.existsSync('package.json')) {
+      const packageJson = this.readPackageJson();
+      return packageJson.name || path.basename(this.projectRoot);
+    }
+    return path.basename(this.projectRoot);
+  }
+}
+
+module.exports = ProjectDetector;

package/lib/utils/status-manager.js

@@ -0,0 +1,107 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+class StatusManager {
+  constructor() {
+    this.statusPath = '.contextkit/status.json';
+  }
+
+  async getStatus() {
+    try {
+      if (await fs.pathExists(this.statusPath)) {
+        return await fs.readJson(this.statusPath);
+      }
+    } catch (error) {
+      console.warn('Warning: Could not read status file:', error.message);
+    }
+    return this.getDefaultStatus();
+  }
+
+  getDefaultStatus() {
+    const packageJson = require('../../package.json');
+    return {
+      version: packageJson.version,
+      installed_at: new Date().toISOString(),
+      last_updated: new Date().toISOString(),
+      analyze: {
+        run: false,
+        last_run: null,
+        customizations: [],
+        project_type: null,
+        package_manager: null
+      },
+      features: {
+        git_hooks: false,
+        standards: true,
+        templates: true
+      }
+    };
+  }
+
+  async saveStatus(status) {
+    try {
+      await fs.ensureDir('.contextkit');
+      await fs.writeJson(this.statusPath, status, { spaces: 2 });
+    } catch (error) {
+      throw new Error(`Failed to save status: ${error.message}`);
+    }
+  }
+
+  async updateAnalyzeStatus(analyzeData) {
+    const status = await this.getStatus();
+    status.analyze = {
+      run: true,
+      last_run: new Date().toISOString(),
+      customizations: analyzeData.customizations || [],
+      project_type: analyzeData.project_type,
+      package_manager: analyzeData.package_manager
+    };
+    status.last_updated = new Date().toISOString();
+    await this.saveStatus(status);
+  }
+
+  async updateFeatureStatus(feature, enabled) {
+    const status = await this.getStatus();
+    status.features[feature] = enabled;
+    status.last_updated = new Date().toISOString();
+    await this.saveStatus(status);
+  }
+
+  async isFirstTimeAnalyze() {
+    const status = await this.getStatus();
+    return !status.analyze.run;
+  }
+
+  async getAnalyzeInfo() {
+    const status = await this.getStatus();
+    return {
+      isFirstTime: !status.analyze.run,
+      lastRun: status.analyze.last_run,
+      projectType: status.analyze.project_type,
+      packageManager: status.analyze.package_manager,
+      customizations: status.analyze.customizations
+    };
+  }
+
+  async updateVersion(version) {
+    const status = await this.getStatus();
+    status.version = version;
+    status.last_updated = new Date().toISOString();
+    await this.saveStatus(status);
+  }
+
+  async resetAnalyzeStatus() {
+    const status = await this.getStatus();
+    status.analyze = {
+      run: false,
+      last_run: null,
+      customizations: [],
+      project_type: null,
+      package_manager: null
+    };
+    status.last_updated = new Date().toISOString();
+    await this.saveStatus(status);
+  }
+}
+
+module.exports = StatusManager;