@nolrm/contextkit 0.7.3

package/lib/commands/run.js

@@ -0,0 +1,232 @@
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const ora = require('ora');
+
+class RunCommand {
+  constructor() {
+    this.workflowPath = null;
+    this.workflowContent = null;
+    this.currentStep = 0;
+    this.steps = [];
+  }
+
+  async run(workflowName, options = {}) {
+    console.log(chalk.magenta(`🚀 Running workflow: ${workflowName}\n`));
+
+    // Find workflow file
+    const possiblePaths = [
+      `.contextkit/instructions/core/${workflowName}.md`,
+      `.contextkit/instructions/${workflowName}.md`,
+      `.contextkit/commands/${workflowName}.md`
+    ];
+
+    let workflowPath = null;
+    for (const possiblePath of possiblePaths) {
+      if (await fs.pathExists(possiblePath)) {
+        workflowPath = possiblePath;
+        break;
+      }
+    }
+
+    if (!workflowPath) {
+      console.log(chalk.red(`❌ Workflow not found: ${workflowName}`));
+      console.log(chalk.yellow('   Searched in:'));
+      possiblePaths.forEach(p => console.log(chalk.dim(`     - ${p}`)));
+      return;
+    }
+
+    this.workflowPath = workflowPath;
+    this.workflowContent = await fs.readFile(workflowPath, 'utf-8');
+
+    // Parse workflow
+    const parsed = this.parseWorkflow(this.workflowContent);
+    
+    if (!parsed) {
+      console.log(chalk.red('❌ Failed to parse workflow'));
+      return;
+    }
+
+    // Execute pre-flight checks
+    if (parsed.preFlight) {
+      await this.executePreFlight(parsed.preFlight);
+    }
+
+    // Execute workflow steps
+    if (parsed.steps && parsed.steps.length > 0) {
+      console.log(chalk.blue(`\n📋 Executing ${parsed.steps.length} step(s)...\n`));
+      
+      for (let i = 0; i < parsed.steps.length; i++) {
+        const step = parsed.steps[i];
+        this.currentStep = i + 1;
+        
+        console.log(chalk.cyan(`\n${'─'.repeat(60)}`));
+        console.log(chalk.bold(`Step ${step.number}: ${step.name || 'Unnamed Step'}`));
+        console.log(chalk.cyan(`${'─'.repeat(60)}\n`));
+        
+        await this.executeStep(step, options);
+      }
+    }
+
+    // Execute post-flight checks
+    if (parsed.postFlight) {
+      await this.executePostFlight(parsed.postFlight);
+    }
+
+    console.log(chalk.green('\n✅ Workflow completed successfully!\n'));
+  }
+
+  parseWorkflow(content) {
+    const result = {
+      preFlight: null,
+      steps: [],
+      postFlight: null
+    };
+
+    // Extract pre-flight
+    const preFlightMatch = content.match(/<pre_flight_check>([\s\S]*?)<\/pre_flight_check>/);
+    if (preFlightMatch) {
+      result.preFlight = preFlightMatch[1].trim();
+    }
+
+    // Extract process_flow and steps
+    const processFlowMatch = content.match(/<process_flow>([\s\S]*?)<\/process_flow>/);
+    if (processFlowMatch) {
+      const processFlow = processFlowMatch[1];
+      
+      // Extract all steps
+      const stepRegex = /<step\s+number="(\d+)"(?:\s+subagent="([^"]+)")?(?:\s+name="([^"]+)")?>([\s\S]*?)<\/step>/g;
+      let stepMatch;
+      
+      while ((stepMatch = stepRegex.exec(processFlow)) !== null) {
+        result.steps.push({
+          number: parseInt(stepMatch[1]),
+          subagent: stepMatch[2] || null,
+          name: stepMatch[3] || null,
+          content: stepMatch[4].trim()
+        });
+      }
+    }
+
+    // Extract post-flight
+    const postFlightMatch = content.match(/<post_flight_check>([\s\S]*?)<\/post_flight_check>/);
+    if (postFlightMatch) {
+      result.postFlight = postFlightMatch[1].trim();
+    }
+
+    return result;
+  }
+
+  async executePreFlight(preFlightContent) {
+    console.log(chalk.blue('🔍 Pre-flight checks...\n'));
+    
+    // Check for EXECUTE directive
+    const executeMatch = preFlightContent.match(/EXECUTE:\s*(.+)/);
+    if (executeMatch) {
+      const filePath = executeMatch[1].trim().replace('@.contextkit/', '.contextkit/');
+      
+      if (await fs.pathExists(filePath)) {
+        const preFlightFile = await fs.readFile(filePath, 'utf-8');
+        console.log(chalk.dim(preFlightFile));
+        console.log('');
+      } else {
+        console.log(chalk.yellow(`⚠️  Pre-flight file not found: ${filePath}`));
+      }
+    } else {
+      console.log(chalk.dim(preFlightContent));
+    }
+  }
+
+  async executeStep(step, options) {
+    // Display step content
+    console.log(chalk.dim(step.content));
+    console.log('');
+
+    // Handle subagent (for now, just note it)
+    if (step.subagent) {
+      console.log(chalk.yellow(`📌 Subagent: ${step.subagent}`));
+      console.log(chalk.dim('   (Subagent delegation would happen here in full implementation)'));
+      console.log('');
+    }
+
+    // Extract instructions from step content
+    const instructions = this.extractInstructions(step.content);
+    
+    // For now, display instructions and wait for user/AI to execute
+    if (instructions.length > 0) {
+      console.log(chalk.blue('📝 Instructions to execute:'));
+      instructions.forEach((inst, idx) => {
+        console.log(chalk.cyan(`   ${idx + 1}. ${inst}`));
+      });
+      console.log('');
+      console.log(chalk.yellow('💡 Use your AI assistant to execute these instructions'));
+      console.log(chalk.yellow('   Or continue manually following the workflow steps\n'));
+    }
+
+    // In interactive mode, wait for confirmation
+    if (options.interactive) {
+      const readline = require('readline').createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+
+      return new Promise((resolve) => {
+        readline.question(chalk.yellow('Press Enter to continue to next step...'), () => {
+          readline.close();
+          resolve();
+        });
+      });
+    }
+  }
+
+  extractInstructions(content) {
+    const instructions = [];
+    
+    // Extract ACTION directives
+    const actionMatches = content.matchAll(/ACTION:\s*(.+)/gi);
+    for (const match of actionMatches) {
+      instructions.push(match[1].trim());
+    }
+
+    // Extract numbered steps
+    const stepMatches = content.matchAll(/^\d+\.\s+(.+)$/gm);
+    for (const match of stepMatches) {
+      instructions.push(match[1].trim());
+    }
+
+    return instructions;
+  }
+
+  async executePostFlight(postFlightContent) {
+    console.log(chalk.blue('\n🔍 Post-flight checks...\n'));
+    
+    // Check for EXECUTE directive
+    const executeMatch = postFlightContent.match(/EXECUTE:\s*(.+)/);
+    if (executeMatch) {
+      const filePath = executeMatch[1].trim().replace('@.contextkit/', '.contextkit/');
+      
+      if (await fs.pathExists(filePath)) {
+        const postFlightFile = await fs.readFile(filePath, 'utf-8');
+        console.log(chalk.dim(postFlightFile));
+        console.log('');
+        
+        // Check for corrections log update instructions
+        if (postFlightFile.includes('corrections log')) {
+          console.log(chalk.yellow('💡 Remember to update corrections.md if any issues occurred'));
+        }
+      } else {
+        console.log(chalk.yellow(`⚠️  Post-flight file not found: ${filePath}`));
+      }
+    } else {
+      console.log(chalk.dim(postFlightContent));
+    }
+  }
+}
+
+async function run(workflowName, options) {
+  const cmd = new RunCommand();
+  await cmd.run(workflowName, options);
+}
+
+module.exports = run;
+

package/lib/commands/status.js

@@ -0,0 +1,253 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const fs = require('fs-extra');
+const path = require('path');
+const StatusManager = require('../utils/status-manager');
+
+class StatusCommand {
+  constructor() {
+    this.configPath = '.contextkit/config.yml';
+    this.statusManager = new StatusManager();
+  }
+
+  async status() {
+    if (!await fs.pathExists(this.configPath)) {
+      console.log(chalk.red('❌ ContextKit is not installed in this project'));
+      console.log(chalk.yellow('💡 Run: contextkit install'));
+      return;
+    }
+
+    try {
+      const config = await this.parseConfig();
+      const projectType = await this.detectProjectType();
+      const packageManager = await this.detectPackageManager();
+      const status = await this.statusManager.getStatus();
+      const analyzeInfo = await this.statusManager.getAnalyzeInfo();
+
+      console.log(chalk.green('🎵 ContextKit Status'));
+      console.log('');
+      
+      console.log(chalk.blue('📦 Installation:'));
+      console.log(`   Version: ${status.version}`);
+      console.log(`   Installed: ${new Date(status.installed_at).toLocaleDateString()}`);
+      console.log(`   Last Updated: ${new Date(status.last_updated).toLocaleDateString()}`);
+      console.log('');
+      
+      console.log(chalk.blue('🔍 Analysis:'));
+      if (analyzeInfo.isFirstTime) {
+        console.log(chalk.yellow('   Status: Not analyzed'));
+        console.log(chalk.blue('   Recommendation: Run @.contextkit/commands/analyze.md to customize standards'));
+      } else {
+        console.log(chalk.green(`   Status: Completed (${new Date(analyzeInfo.lastRun).toLocaleDateString()})`));
+        console.log(chalk.blue(`   Project: ${analyzeInfo.projectType || 'Unknown'}`));
+        console.log(chalk.blue(`   Package Manager: ${analyzeInfo.packageManager || 'Unknown'}`));
+        if (analyzeInfo.customizations.length > 0) {
+          console.log(chalk.blue(`   Customizations: ${analyzeInfo.customizations.length} applied`));
+        }
+      }
+      console.log('');
+      
+      console.log(chalk.blue('✅ Features:'));
+      console.log(`   Git Hooks: ${status.features.git_hooks ? '✅' : '❌'}`);
+      console.log(`   Standards: ${status.features.standards ? '✅' : '❌'}`);
+      console.log(`   Templates: ${status.features.templates ? '✅' : '❌'}`);
+      console.log('');
+      
+      // Check context files
+      console.log(chalk.blue('📚 Context Files (Loaded with ck "prompt"):'));
+      const contextFiles = await this.checkContextFiles();
+      console.log(`   context.md: ${contextFiles.context ? '✅' : '❌'}`);
+      console.log(`   code-style.md: ${contextFiles.codeStyle ? '✅' : '❌'}`);
+      console.log(`   testing.md: ${contextFiles.testing ? '✅' : '❌'}`);
+      console.log(`   architecture.md: ${contextFiles.architecture ? '✅' : '❌'}`);
+      console.log(`   ai-guidelines.md: ${contextFiles.guidelines ? '✅' : '❌'}`);
+      console.log(`   glossary.md: ${contextFiles.glossary ? '✅' : '❌'}`);
+      
+      if (contextFiles.allPresent) {
+        console.log(chalk.green('\n✅ All context files ready for AI prompts!'));
+      } else {
+        console.log(chalk.yellow('\n⚠️  Some context files are missing. Run: contextkit update'));
+      }
+      console.log('');
+
+      // Platform Integrations
+      console.log(chalk.blue('🔌 Platform Integrations:'));
+      await this.checkPlatformIntegrations();
+      console.log('');
+
+      // Check for updates
+      const updateInfo = await this.checkForUpdates(status.version);
+      if (updateInfo.hasUpdate) {
+        console.log(chalk.yellow('🔄 Update Available!'));
+        console.log(`   Current: ${updateInfo.currentVersion}`);
+        console.log(`   Latest: ${updateInfo.latestVersion}`);
+        console.log(chalk.yellow('💡 Run: contextkit update'));
+      } else {
+        console.log(chalk.green('✅ ContextKit is up to date'));
+      }
+
+    } catch (error) {
+      console.log(chalk.red('❌ Error reading ContextKit configuration:'), error.message);
+    }
+  }
+
+  async parseConfig() {
+    const configContent = await fs.readFile(this.configPath, 'utf8');
+    const config = {};
+    
+    // Simple YAML parsing for our config format
+    const lines = configContent.split('\n');
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith('version:')) {
+        config.version = trimmed.split('version:')[1].trim().replace(/"/g, '');
+      } else if (trimmed.startsWith('project_name:')) {
+        config.project_name = trimmed.split('project_name:')[1].trim().replace(/"/g, '');
+      } else if (trimmed.startsWith('project_type:')) {
+        config.project_type = trimmed.split('project_type:')[1].trim().replace(/"/g, '');
+      } else if (trimmed.startsWith('testing:')) {
+        config.features = config.features || {};
+        config.features.testing = trimmed.split('testing:')[1].trim() === 'true';
+      } else if (trimmed.startsWith('documentation:')) {
+        config.features = config.features || {};
+        config.features.documentation = trimmed.split('documentation:')[1].trim() === 'true';
+      } else if (trimmed.startsWith('code_review:')) {
+        config.features = config.features || {};
+        config.features.code_review = trimmed.split('code_review:')[1].trim() === 'true';
+      } else if (trimmed.startsWith('linting:')) {
+        config.features = config.features || {};
+        config.features.linting = trimmed.split('linting:')[1].trim() === 'true';
+      } else if (trimmed.startsWith('type_safety:')) {
+        config.features = config.features || {};
+        config.features.type_safety = trimmed.split('type_safety:')[1].trim() === 'true';
+      } else if (trimmed.startsWith('git_hooks:')) {
+        config.features = config.features || {};
+        config.features.git_hooks = trimmed.split('git_hooks:')[1].trim() === 'true';
+      }
+    }
+
+    return config;
+  }
+
+  async detectProjectType() {
+    if (await fs.pathExists('package.json')) {
+      const packageJson = require(path.join(process.cwd(), 'package.json'));
+      if (packageJson.dependencies?.react || packageJson.devDependencies?.react) {
+        return 'react';
+      } else if (packageJson.dependencies?.vue || packageJson.devDependencies?.vue) {
+        return 'vue';
+      } else if (packageJson.dependencies?.['@angular/core'] || packageJson.devDependencies?.['@angular/core']) {
+        return 'angular';
+      } else if (packageJson.dependencies?.next || packageJson.devDependencies?.next) {
+        return 'nextjs';
+      } else if (packageJson.dependencies?.nuxt || packageJson.devDependencies?.nuxt) {
+        return 'nuxt';
+      } else if (packageJson.dependencies?.svelte || packageJson.devDependencies?.svelte) {
+        return 'svelte';
+      }
+      return 'node';
+    } else if (await fs.pathExists('requirements.txt') || await fs.pathExists('pyproject.toml')) {
+      return 'python';
+    } else if (await fs.pathExists('Cargo.toml')) {
+      return 'rust';
+    } else if (await fs.pathExists('go.mod')) {
+      return 'go';
+    }
+    return 'generic';
+  }
+
+  async detectPackageManager() {
+    if (await fs.pathExists('yarn.lock')) {
+      return 'yarn';
+    } else if (await fs.pathExists('pnpm-lock.yaml')) {
+      return 'pnpm';
+    } else if (await fs.pathExists('package-lock.json')) {
+      return 'npm';
+    } else if (await fs.pathExists('package.json')) {
+      return 'npm';
+    }
+    return 'none';
+  }
+
+  async checkForUpdates(currentVersion) {
+    try {
+      const axios = require('axios');
+      const response = await axios.get('https://api.github.com/repos/nolrm/contextkit/releases/latest', {
+        timeout: 5000
+      });
+      
+      const latestVersion = response.data.tag_name.replace('v', '');
+      const hasUpdate = this.isNewerVersion(latestVersion, currentVersion);
+      
+      return {
+        hasUpdate,
+        currentVersion,
+        latestVersion
+      };
+    } catch (error) {
+      return {
+        hasUpdate: false,
+        currentVersion,
+        latestVersion: 'unknown',
+        error: error.message
+      };
+    }
+  }
+
+  isNewerVersion(latest, current) {
+    const latestParts = latest.split('.').map(Number);
+    const currentParts = current.split('.').map(Number);
+    
+    for (let i = 0; i < Math.max(latestParts.length, currentParts.length); i++) {
+      const latestPart = latestParts[i] || 0;
+      const currentPart = currentParts[i] || 0;
+      
+      if (latestPart > currentPart) return true;
+      if (latestPart < currentPart) return false;
+    }
+    
+    return false;
+  }
+
+  async checkPlatformIntegrations() {
+    const { getAllIntegrationNames, getIntegration } = require('../integrations');
+
+    for (const name of getAllIntegrationNames()) {
+      const integration = getIntegration(name);
+      const result = await integration.validate();
+      const allFiles = [...integration.bridgeFiles, ...integration.generatedFiles];
+
+      if (allFiles.length === 0) continue;
+
+      if (result.valid) {
+        console.log(`   ${integration.displayName}: ${chalk.green('✅')} (${result.present.length} files)`);
+      } else if (result.present.length > 0) {
+        console.log(`   ${integration.displayName}: ${chalk.yellow('⚠️')} (${result.present.length}/${allFiles.length} files)`);
+      } else {
+        console.log(`   ${integration.displayName}: ${chalk.dim('not installed')} → run: ck ${name}`);
+      }
+    }
+  }
+
+  async checkContextFiles() {
+    const checks = {
+      context: await fs.pathExists('.contextkit/context.md'),
+      codeStyle: await fs.pathExists('.contextkit/standards/code-style.md'),
+      testing: await fs.pathExists('.contextkit/standards/testing.md'),
+      architecture: await fs.pathExists('.contextkit/standards/architecture.md'),
+      guidelines: await fs.pathExists('.contextkit/standards/ai-guidelines.md'),
+      glossary: await fs.pathExists('.contextkit/standards/glossary.md')
+    };
+
+    checks.allPresent = checks.context && checks.codeStyle && checks.testing && checks.architecture && checks.guidelines && checks.glossary;
+
+    return checks;
+  }
+}
+
+async function status() {
+  const statusChecker = new StatusCommand();
+  await statusChecker.status();
+}
+
+module.exports = status;