@nolrm/contextkit 0.13.4 → 0.13.7

package/lib/commands/analyze.js

@@ -13,7 +13,7 @@ class AnalyzeCommand {
     console.log(chalk.magenta('🔍 ContextKit Project Analysis\n'));
 
     // Check if contextkit is installed
-    if (!await fs.pathExists('.contextkit/commands/analyze.md')) {
+    if (!(await fs.pathExists('.contextkit/commands/analyze.md'))) {
       console.log(chalk.red('❌ ContextKit not found.'));
       console.log(chalk.yellow('   Run: contextkit install'));
       return;
@@ -24,27 +24,27 @@ class AnalyzeCommand {
     try {
       // Detect monorepo structure
       const monorepoStructure = await this.detectMonorepoStructure();
-      
+
       // Determine analysis scope
       let analysisScope;
-      
+
       // Handle specific package option
       if (options.package) {
         const packagePath = path.resolve(options.package);
-        if (!await fs.pathExists(packagePath)) {
+        if (!(await fs.pathExists(packagePath))) {
           spinner.fail(`Package path not found: ${options.package}`);
           return;
         }
-        
+
         spinner.succeed(`Analyzing specific package: ${options.package}\n`);
         analysisScope = {
           scope: 'package',
           paths: [packagePath],
-          packages: [{ path: packagePath, name: path.basename(packagePath) }]
+          packages: [{ path: packagePath, name: path.basename(packagePath) }],
         };
       } else if (monorepoStructure.isMonorepo) {
         spinner.succeed('Monorepo detected!\n');
-        
+
         if (options.scope) {
           // Use provided scope
           analysisScope = await this.getScopeFromOption(options.scope, monorepoStructure);
@@ -55,7 +55,7 @@ class AnalyzeCommand {
           // Interactive: prompt user
           analysisScope = await this.promptAnalysisScope(monorepoStructure);
         }
-        
+
         this.displayScopeInfo(analysisScope, monorepoStructure);
       } else {
         spinner.succeed('Single package detected\n');
@@ -66,7 +66,7 @@ class AnalyzeCommand {
       const contextSpinner = ora('Loading project context...').start();
       const context = await this.loadProjectContext(analysisScope);
       contextSpinner.succeed('Context loaded successfully\n');
-      
+
       // Load analyze.md instructions
       const analyzeInstructions = await fs.readFile('.contextkit/commands/analyze.md', 'utf-8');
 
@@ -75,14 +75,20 @@ class AnalyzeCommand {
       console.log('─'.repeat(60));
       console.log(analyzeInstructions);
       console.log('─'.repeat(60));
-      
+
       console.log(chalk.blue('\n📊 Project Context:\n'));
       console.log('─'.repeat(60));
-      console.log(JSON.stringify({
-        ...context,
-        analysisScope: analysisScope.scope,
-        analyzedPaths: analysisScope.paths
-      }, null, 2));
+      console.log(
+        JSON.stringify(
+          {
+            ...context,
+            analysisScope: analysisScope.scope,
+            analyzedPaths: analysisScope.paths,
+          },
+          null,
+          2
+        )
+      );
       console.log('─'.repeat(60));
 
       // Update config.yml with analysis scope
@@ -90,7 +96,6 @@ class AnalyzeCommand {
 
       // Show usage instructions
       this.showUsageInstructions(options, analysisScope);
-
     } catch (error) {
       spinner.fail('Failed to load context');
       console.log(chalk.red(error.message));
@@ -101,18 +106,18 @@ class AnalyzeCommand {
     try {
       const yaml = require('js-yaml');
       const configPath = '.contextkit/config.yml';
-      
-      if (!await fs.pathExists(configPath)) {
+
+      if (!(await fs.pathExists(configPath))) {
         return;
       }
 
       const configContent = await fs.readFile(configPath, 'utf-8');
       const config = yaml.load(configContent);
-      
+
       // Update analysis scope info
       config.analysis_scope = analysisScope.scope;
-      config.analyzed_packages = analysisScope.packages.map(p => p.relativePath || p.path);
-      
+      config.analyzed_packages = analysisScope.packages.map((p) => p.relativePath || p.path);
+
       // Write back
       await fs.writeFile(configPath, yaml.dump(config, { lineWidth: 120 }));
     } catch (error) {
@@ -124,7 +129,7 @@ class AnalyzeCommand {
   async loadProjectContext(analysisScope = null) {
     const context = {
       paths: analysisScope?.paths || [process.cwd()],
-      scope: analysisScope?.scope || 'current'
+      scope: analysisScope?.scope || 'current',
     };
 
     // Load context for each path in scope
@@ -146,7 +151,7 @@ class AnalyzeCommand {
     const originalCwd = process.cwd();
     const pathContext = {
       path: analysisPath,
-      relativePath: path.relative(originalCwd, analysisPath)
+      relativePath: path.relative(originalCwd, analysisPath),
     };
 
     try {
@@ -165,7 +170,7 @@ class AnalyzeCommand {
       // Detect frameworks and build tools for this path
       pathContext.frameworks = await this.detectFrameworks();
       pathContext.buildTools = await this.detectBuildTools();
-    } catch (error) {
+    } catch {
       // Continue even if one path fails
     } finally {
       process.chdir(originalCwd);
@@ -182,7 +187,7 @@ class AnalyzeCommand {
       apps: [],
       frontendPackages: [],
       backendPackages: [],
-      fullstackPackages: []
+      fullstackPackages: [],
     };
 
     // Detect monorepo type
@@ -219,7 +224,7 @@ class AnalyzeCommand {
     for (const pkg of allPackages) {
       const pkgType = await this.classifyPackage(pkg.path);
       pkg.type = pkgType;
-      
+
       if (pkgType === 'frontend') {
         structure.frontendPackages.push(pkg);
       } else if (pkgType === 'backend') {
@@ -239,24 +244,24 @@ class AnalyzeCommand {
 
   async scanPackages(dir) {
     const packages = [];
-    if (!await fs.pathExists(dir)) return packages;
+    if (!(await fs.pathExists(dir))) return packages;
 
     const entries = await fs.readdir(dir, { withFileTypes: true });
-    
+
     for (const entry of entries) {
       if (entry.isDirectory()) {
         const packagePath = path.join(dir, entry.name);
         const packageJsonPath = path.join(packagePath, 'package.json');
-        
+
         if (await fs.pathExists(packageJsonPath)) {
           try {
             const packageJson = await fs.readJson(packageJsonPath);
             packages.push({
               name: packageJson.name || entry.name,
               path: packagePath,
-              relativePath: path.relative(process.cwd(), packagePath)
+              relativePath: path.relative(process.cwd(), packagePath),
             });
-          } catch (error) {
+          } catch {
             // Skip invalid package.json
           }
         }
@@ -268,86 +273,112 @@ class AnalyzeCommand {
 
   async classifyPackage(packagePath) {
     const packageJsonPath = path.join(packagePath, 'package.json');
-    if (!await fs.pathExists(packageJsonPath)) return 'unknown';
-    
+    if (!(await fs.pathExists(packageJsonPath))) return 'unknown';
+
     try {
       const pkg = await fs.readJson(packageJsonPath);
       const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
-      
+
       // Frontend indicators
-      const frontendDeps = ['react', 'vue', '@vue', 'angular', '@angular/core', 'next', 'nuxt', 'svelte'];
-      const hasFrontend = frontendDeps.some(dep => deps[dep]);
-      
+      const frontendDeps = [
+        'react',
+        'vue',
+        '@vue',
+        'angular',
+        '@angular/core',
+        'next',
+        'nuxt',
+        'svelte',
+      ];
+      const hasFrontend = frontendDeps.some((dep) => deps[dep]);
+
       // Backend indicators
-      const backendDeps = ['express', 'fastify', 'koa', '@nestjs/core', 'django', 'flask', 'fastapi'];
-      const hasBackend = backendDeps.some(dep => deps[dep]);
-      
+      const backendDeps = [
+        'express',
+        'fastify',
+        'koa',
+        '@nestjs/core',
+        'django',
+        'flask',
+        'fastapi',
+      ];
+      let hasBackend = backendDeps.some((dep) => deps[dep]);
+
       // Check for backend file patterns
       if (!hasBackend) {
         const serverFiles = ['server.js', 'server.ts', 'index.js', 'index.ts', 'app.js', 'app.ts'];
         for (const file of serverFiles) {
-          if (await fs.pathExists(path.join(packagePath, file)) ||
-              await fs.pathExists(path.join(packagePath, 'src', file))) {
+          if (
+            (await fs.pathExists(path.join(packagePath, file))) ||
+            (await fs.pathExists(path.join(packagePath, 'src', file)))
+          ) {
             hasBackend = true;
             break;
           }
         }
       }
-      
+
       if (hasFrontend && hasBackend) return 'fullstack';
       if (hasFrontend) return 'frontend';
       if (hasBackend) return 'backend';
-      
+
       // Check directory structure
-      if (await fs.pathExists(path.join(packagePath, 'src', 'components')) ||
-          await fs.pathExists(path.join(packagePath, 'components'))) {
+      if (
+        (await fs.pathExists(path.join(packagePath, 'src', 'components'))) ||
+        (await fs.pathExists(path.join(packagePath, 'components')))
+      ) {
         return 'frontend';
       }
-      
-      if (await fs.pathExists(path.join(packagePath, 'src', 'server')) ||
-          await fs.pathExists(path.join(packagePath, 'src', 'api'))) {
+
+      if (
+        (await fs.pathExists(path.join(packagePath, 'src', 'server'))) ||
+        (await fs.pathExists(path.join(packagePath, 'src', 'api')))
+      ) {
         return 'backend';
       }
-      
+
       return 'unknown';
-    } catch (error) {
+    } catch {
       return 'unknown';
     }
   }
 
   async promptAnalysisScope(monorepoStructure) {
     const choices = [];
-    
+
     if (monorepoStructure.frontendPackages.length > 0) {
-      const frontendNames = monorepoStructure.frontendPackages.map(p => p.name).join(', ');
+      const frontendNames = monorepoStructure.frontendPackages.map((p) => p.name).join(', ');
       choices.push({
         name: `Frontend (${monorepoStructure.frontendPackages.length} package(s): ${frontendNames})`,
         value: 'frontend',
-        packages: monorepoStructure.frontendPackages
+        packages: monorepoStructure.frontendPackages,
       });
     }
-    
+
     if (monorepoStructure.backendPackages.length > 0) {
-      const backendNames = monorepoStructure.backendPackages.map(p => p.name).join(', ');
+      const backendNames = monorepoStructure.backendPackages.map((p) => p.name).join(', ');
       choices.push({
         name: `Backend (${monorepoStructure.backendPackages.length} package(s): ${backendNames})`,
         value: 'backend',
-        packages: monorepoStructure.backendPackages
+        packages: monorepoStructure.backendPackages,
       });
     }
-    
-    if (monorepoStructure.frontendPackages.length > 0 && monorepoStructure.backendPackages.length > 0) {
+
+    if (
+      monorepoStructure.frontendPackages.length > 0 &&
+      monorepoStructure.backendPackages.length > 0
+    ) {
       choices.push({
         name: 'Both (Frontend + Backend) - Separate standards',
         value: 'both',
-        packages: [...monorepoStructure.frontendPackages, ...monorepoStructure.backendPackages]
+        packages: [...monorepoStructure.frontendPackages, ...monorepoStructure.backendPackages],
       });
     }
-    
+
     choices.push({
       name: 'Current directory only',
       value: 'current',
-      packages: []
+      packages: [],
     });
 
     if (choices.length === 1) {
@@ -360,17 +391,15 @@ class AnalyzeCommand {
         type: 'list',
         name: 'scope',
         message: 'Which part of the monorepo should we analyze?',
-        choices: choices.map(c => c.name)
-      }
+        choices: choices.map((c) => c.name),
+      },
     ]);
 
-    const selected = choices.find(c => c.name === scope);
+    const selected = choices.find((c) => c.name === scope);
     return {
       scope: selected.value,
       packages: selected.packages,
-      paths: selected.packages.length > 0 
-        ? selected.packages.map(p => p.path)
-        : [process.cwd()]
+      paths: selected.packages.length > 0 ? selected.packages.map((p) => p.path) : [process.cwd()],
     };
   }
 
@@ -380,19 +409,21 @@ class AnalyzeCommand {
         return {
           scope: 'frontend',
           packages: monorepoStructure.frontendPackages,
-          paths: monorepoStructure.frontendPackages.map(p => p.path)
+          paths: monorepoStructure.frontendPackages.map((p) => p.path),
         };
       case 'backend':
         return {
           scope: 'backend',
           packages: monorepoStructure.backendPackages,
-          paths: monorepoStructure.backendPackages.map(p => p.path)
+          paths: monorepoStructure.backendPackages.map((p) => p.path),
         };
       case 'both':
         return {
           scope: 'both',
           packages: [...monorepoStructure.frontendPackages, ...monorepoStructure.backendPackages],
-          paths: [...monorepoStructure.frontendPackages, ...monorepoStructure.backendPackages].map(p => p.path)
+          paths: [...monorepoStructure.frontendPackages, ...monorepoStructure.backendPackages].map(
+            (p) => p.path
+          ),
         };
       default:
         return { scope: 'current', paths: [process.cwd()], packages: [] };
@@ -404,10 +435,10 @@ class AnalyzeCommand {
     console.log(chalk.dim(`   Type: ${monorepoStructure.type || 'workspace'}`));
     console.log(chalk.dim(`   Frontend packages: ${monorepoStructure.frontendPackages.length}`));
     console.log(chalk.dim(`   Backend packages: ${monorepoStructure.backendPackages.length}`));
-    
+
     console.log(chalk.blue(`\n🎯 Analysis Scope: ${analysisScope.scope}\n`));
     if (analysisScope.packages.length > 0) {
-      analysisScope.packages.forEach(pkg => {
+      analysisScope.packages.forEach((pkg) => {
         console.log(chalk.dim(`   • ${pkg.name} (${pkg.type})`));
       });
     }
@@ -419,7 +450,7 @@ class AnalyzeCommand {
       if (await fs.pathExists('package.json')) {
         return await fs.readJson('package.json');
       }
-    } catch (error) {
+    } catch {
       // Ignore
     }
     return {};
@@ -430,7 +461,7 @@ class AnalyzeCommand {
       hasSrc: await fs.pathExists('src'),
       hasApp: await fs.pathExists('src/app'),
       hasComponents: await fs.pathExists('src/components'),
-      isMonorepo: await fs.pathExists('packages') || await fs.pathExists('apps'),
+      isMonorepo: (await fs.pathExists('packages')) || (await fs.pathExists('apps')),
       frameworks: await this.detectFrameworks(),
       buildTools: await this.detectBuildTools(),
     };
@@ -462,13 +493,13 @@ class AnalyzeCommand {
   async detectBuildTools() {
     const tools = [];
 
-    if (await fs.pathExists('vite.config.js') || await fs.pathExists('vite.config.ts')) {
+    if ((await fs.pathExists('vite.config.js')) || (await fs.pathExists('vite.config.ts'))) {
       tools.push('Vite');
     }
-    if (await fs.pathExists('webpack.config.js') || await fs.pathExists('webpack.config.ts')) {
+    if ((await fs.pathExists('webpack.config.js')) || (await fs.pathExists('webpack.config.ts'))) {
       tools.push('Webpack');
     }
-    if (await fs.pathExists('rollup.config.js') || await fs.pathExists('rollup.config.ts')) {
+    if ((await fs.pathExists('rollup.config.js')) || (await fs.pathExists('rollup.config.ts'))) {
       tools.push('Rollup');
     }
 
@@ -478,25 +509,26 @@ class AnalyzeCommand {
   async detectAITools() {
     const ToolDetector = require('../utils/tool-detector');
     const detector = new ToolDetector();
-    const tools = await detector.detectAll();
+    const _tools = await detector.detectAll();
     const summary = detector.getSummary();
 
     return {
       detected: summary.all,
       editors: summary.editors,
       cli: summary.cli,
-      count: summary.count
+      count: summary.count,
     };
   }
 
   showUsageInstructions(options, analysisScope = null) {
     console.log(chalk.blue('\n💡 To execute analysis with AI:\n'));
-    
+
     console.log(chalk.yellow('1. Using contextkit AI chat:'));
-    const scopeHint = analysisScope?.scope === 'both' 
-      ? ' (will generate separate frontend/backend standards)'
-      : '';
-    console.log(`   contextkit ai "read .contextkit/commands/analyze.md and execute analysis${scopeHint}"\n`);
+    const scopeHint =
+      analysisScope?.scope === 'both' ? ' (will generate separate frontend/backend standards)' : '';
+    console.log(
+      `   contextkit ai "read .contextkit/commands/analyze.md and execute analysis${scopeHint}"\n`
+    );
 
     console.log(chalk.yellow('2. Using Aider (if installed):'));
     console.log('   aider');
@@ -506,14 +538,22 @@ class AnalyzeCommand {
     console.log('   claude "read .contextkit/commands/analyze.md and execute analysis"\n');
 
     console.log(chalk.blue('📝 Next: Use the AI tool of your choice to execute the analysis'));
-    console.log(chalk.blue('✨ The AI will generate content for your skeleton .contextkit/standards/*.md files'));
-    
+    console.log(
+      chalk.blue(
+        '✨ The AI will generate content for your skeleton .contextkit/standards/*.md files'
+      )
+    );
+
     if (analysisScope?.scope === 'both') {
-      console.log(chalk.blue('📦 For monorepo with both frontend and backend, standards will be generated separately:'));
+      console.log(
+        chalk.blue(
+          '📦 For monorepo with both frontend and backend, standards will be generated separately:'
+        )
+      );
       console.log(chalk.dim('   • .contextkit/standards/frontend/'));
       console.log(chalk.dim('   • .contextkit/standards/backend/'));
     }
-    
+
     console.log('');
     console.log(chalk.yellow('📋 What AI will generate:'));
     console.log('   • code-style.md - Extract formatting & conventions from your code');
@@ -526,8 +566,8 @@ class AnalyzeCommand {
     console.log(chalk.yellow('⚠️  After generation completes:'));
     console.log(chalk.yellow('   1. Review generated files in .contextkit/standards/'));
     console.log(chalk.yellow('   2. Edit and refine to match YOUR exact needs'));
-    console.log(chalk.yellow('   3. Commit them to your repo (they\'re part of your project now)'));
-    
+    console.log(chalk.yellow("   3. Commit them to your repo (they're part of your project now)"));
+
     if (analysisScope?.scope && analysisScope.scope !== 'current') {
       console.log('');
       console.log(chalk.blue('💡 Tip: Run with --scope flag for non-interactive mode:'));

package/lib/commands/check.js

@@ -1,6 +1,5 @@
 const chalk = require('chalk');
 const fs = require('fs-extra');
-const path = require('path');
 const yaml = require('js-yaml');
 
 class CheckCommand {
@@ -13,7 +12,7 @@ class CheckCommand {
   async run(options = {}) {
     console.log(chalk.magenta('🔍 ContextKit Validation Check\n'));
 
-    if (!await fs.pathExists('.contextkit/config.yml')) {
+    if (!(await fs.pathExists('.contextkit/config.yml'))) {
       console.log(chalk.red('❌ ContextKit not installed'));
       console.log(chalk.yellow('   Run: contextkit install'));
       return;
@@ -88,7 +87,7 @@ class CheckCommand {
 
     for (const file of config.required) {
       const filePath = `.contextkit/${file}`;
-      if (!await fs.pathExists(filePath)) {
+      if (!(await fs.pathExists(filePath))) {
         this.errors.push(`Required file missing: ${file}`);
       } else {
         this.info.push(`✓ Required file exists: ${file}`);
@@ -103,13 +102,13 @@ class CheckCommand {
 
     for (const file of config.optional) {
       const filePath = `.contextkit/${file}`;
-      if (!await fs.pathExists(filePath)) {
+      if (!(await fs.pathExists(filePath))) {
         this.warnings.push(`Optional file missing: ${file}`);
       }
     }
   }
 
-  async checkStandardsFreshness(config) {
+  async checkStandardsFreshness(_config) {
     // Load policy to get freshness threshold
     let freshnessDays = 90; // default
     try {
@@ -120,7 +119,7 @@ class CheckCommand {
           freshnessDays = policy.enforcement.standards.freshness_days;
         }
       }
-    } catch (error) {
+    } catch {
       // Policy file might not exist or be invalid, use default
     }
 
@@ -130,7 +129,7 @@ class CheckCommand {
       'standards/testing.md',
       'standards/architecture.md',
       'standards/ai-guidelines.md',
-      'standards/workflows.md'
+      'standards/workflows.md',
     ];
 
     for (const file of standardsFiles) {
@@ -138,7 +137,7 @@ class CheckCommand {
       if (await fs.pathExists(filePath)) {
         const stats = await fs.stat(filePath);
         const daysSinceUpdate = (Date.now() - stats.mtime.getTime()) / (1000 * 60 * 60 * 24);
-        
+
         if (daysSinceUpdate > freshnessDays) {
           this.warnings.push(
             `Standards file outdated: ${file} (last updated ${Math.floor(daysSinceUpdate)} days ago, threshold: ${freshnessDays} days)`
@@ -148,9 +147,9 @@ class CheckCommand {
     }
   }
 
-  async checkPolicyCompliance(config) {
+  async checkPolicyCompliance(_config) {
     try {
-      if (!await fs.pathExists('.contextkit/policies/policy.yml')) {
+      if (!(await fs.pathExists('.contextkit/policies/policy.yml'))) {
         this.warnings.push('Policy file missing: policies/policy.yml');
         return;
       }
@@ -171,7 +170,9 @@ class CheckCommand {
           if (await fs.pathExists(testingPath)) {
             const content = await fs.readFile(testingPath, 'utf-8');
             if (!content.includes('numbered') && !content.includes('1., 2., 3.')) {
-              this.errors.push('Testing standards must require numbered test cases (policy: block)');
+              this.errors.push(
+                'Testing standards must require numbered test cases (policy: block)'
+              );
             }
           }
         }
@@ -212,7 +213,7 @@ class CheckCommand {
     for (const dep of deprecations) {
       if (await fs.pathExists(dep.file)) {
         if (dep.bridge) {
-          if (!await fs.pathExists(dep.bridge)) {
+          if (!(await fs.pathExists(dep.bridge))) {
             this.warnings.push(dep.message);
           }
         } else {
@@ -240,7 +241,9 @@ class CheckCommand {
     }
 
     if (!anyBridge) {
-      this.warnings.push('No platform bridge files found. Run: ck <platform> (e.g., ck claude, ck cursor)');
+      this.warnings.push(
+        'No platform bridge files found. Run: ck <platform> (e.g., ck claude, ck cursor)'
+      );
     }
   }
 
@@ -249,21 +252,21 @@ class CheckCommand {
 
     if (this.errors.length > 0) {
       console.log(chalk.red(`\n❌ Errors (${this.errors.length}):`));
-      this.errors.forEach(error => {
+      this.errors.forEach((error) => {
         console.log(chalk.red(`  • ${error}`));
       });
     }
 
     if (this.warnings.length > 0) {
       console.log(chalk.yellow(`\n⚠️  Warnings (${this.warnings.length}):`));
-      this.warnings.forEach(warning => {
+      this.warnings.forEach((warning) => {
         console.log(chalk.yellow(`  • ${warning}`));
       });
     }
 
     if (this.info.length > 0 && options.verbose) {
       console.log(chalk.blue(`\nℹ️  Info (${this.info.length}):`));
-      this.info.forEach(info => {
+      this.info.forEach((info) => {
         console.log(chalk.blue(`  • ${info}`));
       });
     }
@@ -274,7 +277,11 @@ class CheckCommand {
     if (this.errors.length === 0 && this.warnings.length === 0) {
       console.log(chalk.green('\n✅ All checks passed!'));
     } else if (this.errors.length === 0) {
-      console.log(chalk.yellow(`\n⚠️  ${this.warnings.length} warning(s) found (use --strict to fail on warnings)`));
+      console.log(
+        chalk.yellow(
+          `\n⚠️  ${this.warnings.length} warning(s) found (use --strict to fail on warnings)`
+        )
+      );
     } else {
       console.log(chalk.red(`\n❌ ${this.errors.length} error(s) found`));
     }
@@ -287,4 +294,3 @@ async function check(options) {
 }
 
 module.exports = check;
-