create-universal-ai-context 2.0.0

package/templates/base/tools/lib/detector.js

@@ -0,0 +1,350 @@
+/**
+ * Claude Context Engineering - Tech Stack Detector
+ *
+ * Auto-detects technology stack from project files.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { glob } = require('glob');
+
+/**
+ * Tech stack detection signatures
+ */
+const TECH_SIGNATURES = {
+  // Languages
+  languages: {
+    python: {
+      files: ['requirements.txt', 'pyproject.toml', 'setup.py', 'Pipfile', 'poetry.lock'],
+      extensions: ['.py'],
+    },
+    javascript: {
+      files: ['package.json', 'yarn.lock', 'pnpm-lock.yaml'],
+      extensions: ['.js', '.mjs', '.cjs'],
+    },
+    typescript: {
+      files: ['tsconfig.json'],
+      extensions: ['.ts', '.tsx'],
+    },
+    go: {
+      files: ['go.mod', 'go.sum'],
+      extensions: ['.go'],
+    },
+    rust: {
+      files: ['Cargo.toml', 'Cargo.lock'],
+      extensions: ['.rs'],
+    },
+    java: {
+      files: ['pom.xml', 'build.gradle', 'build.gradle.kts'],
+      extensions: ['.java'],
+    },
+    csharp: {
+      files: ['*.csproj', '*.sln'],
+      extensions: ['.cs'],
+    },
+    ruby: {
+      files: ['Gemfile', 'Gemfile.lock'],
+      extensions: ['.rb'],
+    },
+    php: {
+      files: ['composer.json', 'composer.lock'],
+      extensions: ['.php'],
+    },
+  },
+
+  // Frameworks
+  frameworks: {
+    // Python
+    fastapi: {
+      language: 'python',
+      patterns: ['fastapi', 'FastAPI', '@router', 'APIRouter'],
+      files: [],
+    },
+    django: {
+      language: 'python',
+      patterns: ['django.conf', 'INSTALLED_APPS', 'from django'],
+      files: ['manage.py'],
+    },
+    flask: {
+      language: 'python',
+      patterns: ['Flask(__name__)', '@app.route', 'from flask'],
+      files: [],
+    },
+
+    // JavaScript/TypeScript
+    react: {
+      language: 'javascript',
+      patterns: ['react', 'React', 'useState', 'useEffect'],
+      packageDeps: ['react', 'react-dom'],
+    },
+    nextjs: {
+      language: 'javascript',
+      patterns: ['next/'],
+      files: ['next.config.js', 'next.config.mjs'],
+      packageDeps: ['next'],
+    },
+    express: {
+      language: 'javascript',
+      patterns: ['express()', 'app.use', 'app.get', 'router.'],
+      packageDeps: ['express'],
+    },
+    nestjs: {
+      language: 'typescript',
+      patterns: ['@nestjs/', '@Controller', '@Injectable'],
+      packageDeps: ['@nestjs/core'],
+    },
+    vue: {
+      language: 'javascript',
+      patterns: ['<template>', 'Vue.'],
+      packageDeps: ['vue'],
+    },
+
+    // Go
+    gin: {
+      language: 'go',
+      patterns: ['gin.', 'gin-gonic'],
+      files: [],
+    },
+    echo: {
+      language: 'go',
+      patterns: ['echo.', 'labstack/echo'],
+      files: [],
+    },
+
+    // Ruby
+    rails: {
+      language: 'ruby',
+      patterns: ['Rails.application', 'ActionController', 'ActiveRecord'],
+      files: ['config/routes.rb'],
+    },
+
+    // Rust
+    actix: {
+      language: 'rust',
+      patterns: ['actix_web', 'actix-web'],
+      files: [],
+    },
+    axum: {
+      language: 'rust',
+      patterns: ['axum::'],
+      files: [],
+    },
+  },
+
+  // Databases
+  databases: {
+    postgresql: {
+      patterns: ['postgresql', 'postgres', 'psycopg', 'pg'],
+      envVars: ['DATABASE_URL', 'POSTGRES_'],
+    },
+    mysql: {
+      patterns: ['mysql', 'mariadb'],
+      envVars: ['MYSQL_'],
+    },
+    mongodb: {
+      patterns: ['mongodb', 'mongoose', 'pymongo'],
+      envVars: ['MONGO_'],
+    },
+    redis: {
+      patterns: ['redis', 'ioredis'],
+      envVars: ['REDIS_'],
+    },
+    sqlite: {
+      patterns: ['sqlite', 'sqlite3'],
+      files: ['*.db', '*.sqlite'],
+    },
+  },
+};
+
+/**
+ * Detect technology stack
+ */
+async function detectTechStack(projectRoot, options = {}) {
+  const { hint = null } = options;
+
+  const result = {
+    stack: '',
+    languages: [],
+    frameworks: [],
+    databases: [],
+    projectName: path.basename(projectRoot),
+    fileCount: 0,
+    loc: 0,
+  };
+
+  // If hint provided, use it
+  if (hint) {
+    result.stack = hint;
+    return result;
+  }
+
+  // Detect languages
+  for (const [lang, signature] of Object.entries(TECH_SIGNATURES.languages)) {
+    // Check for signature files
+    for (const sigFile of signature.files) {
+      if (fs.existsSync(path.join(projectRoot, sigFile))) {
+        if (!result.languages.includes(lang)) {
+          result.languages.push(lang);
+        }
+        break;
+      }
+    }
+
+    // Check for file extensions
+    if (signature.extensions) {
+      for (const ext of signature.extensions) {
+        const files = await glob(`**/*${ext}`, {
+          cwd: projectRoot,
+          ignore: ['node_modules/**', 'vendor/**', '.git/**', 'dist/**', 'build/**'],
+          nodir: true,
+        });
+
+        if (files.length > 0) {
+          if (!result.languages.includes(lang)) {
+            result.languages.push(lang);
+          }
+          result.fileCount += files.length;
+          break;
+        }
+      }
+    }
+  }
+
+  // Detect frameworks
+  for (const [framework, signature] of Object.entries(TECH_SIGNATURES.frameworks)) {
+    // Check for package.json dependencies
+    if (signature.packageDeps) {
+      const pkgPath = path.join(projectRoot, 'package.json');
+      if (fs.existsSync(pkgPath)) {
+        try {
+          const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+          const allDeps = {
+            ...pkg.dependencies,
+            ...pkg.devDependencies,
+          };
+
+          for (const dep of signature.packageDeps) {
+            if (allDeps[dep]) {
+              if (!result.frameworks.includes(framework)) {
+                result.frameworks.push(framework);
+              }
+              break;
+            }
+          }
+        } catch {
+          // Ignore JSON parse errors
+        }
+      }
+    }
+
+    // Check for signature files
+    if (signature.files) {
+      for (const sigFile of signature.files) {
+        if (fs.existsSync(path.join(projectRoot, sigFile))) {
+          if (!result.frameworks.includes(framework)) {
+            result.frameworks.push(framework);
+          }
+          break;
+        }
+      }
+    }
+
+    // Check for patterns in source files (sample)
+    if (signature.patterns && result.languages.includes(signature.language)) {
+      // Sample a few source files
+      const ext = TECH_SIGNATURES.languages[signature.language]?.extensions?.[0];
+      if (ext) {
+        const sampleFiles = await glob(`**/*${ext}`, {
+          cwd: projectRoot,
+          ignore: ['node_modules/**', 'vendor/**', '.git/**'],
+          nodir: true,
+        });
+
+        // Check first 5 files
+        for (const file of sampleFiles.slice(0, 5)) {
+          const content = fs.readFileSync(path.join(projectRoot, file), 'utf8');
+
+          for (const pattern of signature.patterns) {
+            if (content.includes(pattern)) {
+              if (!result.frameworks.includes(framework)) {
+                result.frameworks.push(framework);
+              }
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Detect databases
+  for (const [db, signature] of Object.entries(TECH_SIGNATURES.databases)) {
+    // Check environment files
+    const envFiles = ['.env', '.env.example', '.env.local'];
+    for (const envFile of envFiles) {
+      const envPath = path.join(projectRoot, envFile);
+      if (fs.existsSync(envPath)) {
+        const content = fs.readFileSync(envPath, 'utf8');
+
+        if (signature.envVars) {
+          for (const envVar of signature.envVars) {
+            if (content.includes(envVar)) {
+              if (!result.databases.includes(db)) {
+                result.databases.push(db);
+              }
+              break;
+            }
+          }
+        }
+      }
+    }
+
+    // Check for patterns in config files
+    if (signature.patterns) {
+      const configFiles = ['package.json', 'requirements.txt', 'pyproject.toml', 'Cargo.toml'];
+      for (const configFile of configFiles) {
+        const configPath = path.join(projectRoot, configFile);
+        if (fs.existsSync(configPath)) {
+          const content = fs.readFileSync(configPath, 'utf8').toLowerCase();
+
+          for (const pattern of signature.patterns) {
+            if (content.includes(pattern.toLowerCase())) {
+              if (!result.databases.includes(db)) {
+                result.databases.push(db);
+              }
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Build stack string
+  const stackParts = [];
+  if (result.languages.length > 0) {
+    stackParts.push(result.languages.map(l => capitalize(l)).join(', '));
+  }
+  if (result.frameworks.length > 0) {
+    stackParts.push(result.frameworks.map(f => capitalize(f)).join(', '));
+  }
+  if (result.databases.length > 0) {
+    stackParts.push(result.databases.map(d => capitalize(d)).join(', '));
+  }
+
+  result.stack = stackParts.join(' + ') || 'Unknown';
+
+  return result;
+}
+
+/**
+ * Capitalize first letter
+ */
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+module.exports = {
+  detectTechStack,
+  TECH_SIGNATURES,
+};

package/templates/base/tools/lib/diagnose.js

@@ -0,0 +1,206 @@
+/**
+ * Claude Context Engineering - Diagnostics Module
+ *
+ * System health diagnostics and issue detection with optional auto-fix.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const { findClaudeDir, loadJsonFile } = require('./config-loader');
+const { logger } = require('./logger');
+const { validate } = require('./validate');
+
+/**
+ * Diagnostic procedures for common issues
+ */
+const DIAGNOSTIC_PROCEDURES = {
+  'corrupted-settings': {
+    name: 'Corrupted Settings',
+    detect: async (claudeDir) => {
+      const settingsPath = path.join(claudeDir, 'settings.json');
+      if (!fs.existsSync(settingsPath)) return false;
+
+      try {
+        JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+        return false;
+      } catch {
+        return true;
+      }
+    },
+    fix: async (claudeDir) => {
+      const settingsPath = path.join(claudeDir, 'settings.json');
+      const backupPath = settingsPath + '.corrupted';
+
+      // Backup corrupted file
+      fs.renameSync(settingsPath, backupPath);
+
+      // Create default settings
+      const defaults = require('./config-loader').configLoader.getDefaults();
+      defaults.$schema = './schemas/settings.schema.json';
+      defaults.version = '1.1.0';
+
+      fs.writeFileSync(settingsPath, JSON.stringify(defaults, null, 2));
+
+      return `Settings restored from defaults. Backup saved to ${backupPath}`;
+    },
+  },
+
+  'incomplete-init': {
+    name: 'Incomplete Initialization',
+    detect: async (claudeDir) => {
+      const progressPath = path.join(claudeDir, 'INIT_PROGRESS.json');
+      if (!fs.existsSync(progressPath)) return false;
+
+      const progress = loadJsonFile(progressPath);
+      return progress.status !== 'COMPLETED';
+    },
+    fix: async (claudeDir) => {
+      console.log(chalk.yellow('  To resume initialization, run:'));
+      console.log(chalk.cyan('    npx claude-context init --resume'));
+      return 'Manual action required';
+    },
+  },
+
+  'missing-schemas': {
+    name: 'Missing Schema Directory',
+    detect: async (claudeDir) => {
+      return !fs.existsSync(path.join(claudeDir, 'schemas'));
+    },
+    fix: async (claudeDir) => {
+      const schemaDir = path.join(claudeDir, 'schemas');
+      fs.mkdirSync(schemaDir, { recursive: true });
+      return 'Created schemas directory';
+    },
+  },
+
+  'missing-logs-dir': {
+    name: 'Missing Logs Directory',
+    detect: async (claudeDir) => {
+      return !fs.existsSync(path.join(claudeDir, 'logs'));
+    },
+    fix: async (claudeDir) => {
+      fs.mkdirSync(path.join(claudeDir, 'logs'), { recursive: true });
+      return 'Created logs directory';
+    },
+  },
+
+  'orphaned-workflows': {
+    name: 'Orphaned Workflow Files',
+    detect: async (claudeDir) => {
+      const indexPath = path.join(claudeDir, 'context', 'WORKFLOW_INDEX.md');
+      const workflowDir = path.join(claudeDir, 'context', 'workflows');
+
+      if (!fs.existsSync(indexPath) || !fs.existsSync(workflowDir)) {
+        return false;
+      }
+
+      const indexContent = fs.readFileSync(indexPath, 'utf8');
+      const workflowFiles = fs.readdirSync(workflowDir).filter(f => f.endsWith('.md'));
+
+      for (const wf of workflowFiles) {
+        const baseName = wf.replace('.md', '');
+        if (!indexContent.includes(baseName)) {
+          return true;
+        }
+      }
+
+      return false;
+    },
+    fix: async (claudeDir) => {
+      return 'Orphaned workflows detected. Update WORKFLOW_INDEX.md to include all workflows.';
+    },
+  },
+};
+
+/**
+ * Run diagnostics
+ */
+async function diagnose(options = {}) {
+  const { fix = false, verbose = false } = options;
+  const op = logger.startOperation('diagnose');
+
+  const claudeDir = findClaudeDir();
+
+  console.log(chalk.cyan('\n🔬 Running Diagnostics...\n'));
+
+  const results = {
+    timestamp: new Date().toISOString(),
+    issues: [],
+    fixed: [],
+    suggestions: [],
+  };
+
+  // Run all diagnostic procedures
+  for (const [key, procedure] of Object.entries(DIAGNOSTIC_PROCEDURES)) {
+    if (verbose) {
+      console.log(chalk.gray(`  Checking: ${procedure.name}...`));
+    }
+
+    try {
+      const detected = await procedure.detect(claudeDir);
+
+      if (detected) {
+        console.log(chalk.yellow(`  ⚠️  Issue detected: ${procedure.name}`));
+
+        results.issues.push({
+          key,
+          name: procedure.name,
+          fixable: !!procedure.fix,
+        });
+
+        if (fix && procedure.fix) {
+          console.log(chalk.cyan(`     Attempting fix...`));
+          const fixResult = await procedure.fix(claudeDir);
+          console.log(chalk.green(`     ✓ ${fixResult}`));
+          results.fixed.push({ key, result: fixResult });
+        } else if (procedure.fix) {
+          console.log(chalk.gray(`     Run with --fix to attempt auto-repair`));
+        }
+      } else if (verbose) {
+        console.log(chalk.green(`  ✓ ${procedure.name}: OK`));
+      }
+    } catch (error) {
+      console.log(chalk.red(`  ✗ Error checking ${procedure.name}: ${error.message}`));
+      results.issues.push({
+        key,
+        name: procedure.name,
+        error: error.message,
+      });
+    }
+  }
+
+  // Run validation as part of diagnostics
+  console.log(chalk.white('\nRunning validation checks...'));
+  const validation = await validate({ all: true, claudeDir });
+
+  if (validation.summary.failed > 0) {
+    results.suggestions.push('Run validation to see detailed issues: npx claude-context validate');
+  }
+
+  // Summary
+  console.log(chalk.white('\n📋 Diagnostic Summary'));
+  console.log(chalk.gray('─'.repeat(50)));
+
+  if (results.issues.length === 0) {
+    console.log(chalk.green('  ✓ No issues detected'));
+  } else {
+    console.log(chalk.yellow(`  Issues found: ${results.issues.length}`));
+    if (results.fixed.length > 0) {
+      console.log(chalk.green(`  Issues fixed: ${results.fixed.length}`));
+    }
+  }
+
+  if (results.suggestions.length > 0) {
+    console.log(chalk.white('\n💡 Suggestions:'));
+    results.suggestions.forEach(s => console.log(chalk.gray(`  - ${s}`)));
+  }
+
+  op.success();
+  return results;
+}
+
+module.exports = {
+  diagnose,
+  DIAGNOSTIC_PROCEDURES,
+};