create-claude-context 1.2.0 → 1.2.1

package/lib/environment-detector.js

@@ -0,0 +1,239 @@
+/**
+ * Environment Detector
+ *
+ * Detects execution context to determine analysis mode:
+ * - full-ai: Running inside Claude Code with API access
+ * - hybrid: Running inside Claude Code without direct API access
+ * - standalone: Running via npx without Claude Code
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Environment indicators for Claude Code detection
+ */
+const CLAUDE_INDICATORS = {
+  // Environment variables set by Claude Code
+  envVars: [
+    'CLAUDE_CODE_SESSION',
+    'CLAUDE_SESSION_ID',
+    'CLAUDE_AGENT_ID',
+    'ANTHROPIC_API_KEY',
+    'CLAUDE_API_KEY'
+  ],
+
+  // Directories that indicate Claude Code presence
+  directories: [
+    path.join(os.homedir(), '.claude'),
+    path.join(os.homedir(), '.claude-code'),
+    path.join(os.homedir(), '.config', 'claude-code')
+  ],
+
+  // Files that indicate active Claude Code session
+  sessionFiles: [
+    '.claude-session',
+    '.claude-code-session'
+  ]
+};
+
+/**
+ * Capability definitions by mode
+ */
+const CAPABILITIES = {
+  'full-ai': [
+    'workflow-discovery',
+    'call-tracing',
+    'semantic-analysis',
+    'architecture-understanding',
+    'smart-documentation'
+  ],
+  'hybrid': [
+    'workflow-discovery',
+    'basic-analysis',
+    'pattern-matching'
+  ],
+  'standalone': [
+    'static-analysis',
+    'pattern-matching',
+    'structure-mapping'
+  ]
+};
+
+/**
+ * Detect if running inside a Claude Code session
+ * @returns {boolean}
+ */
+function isClaudeCodeSession() {
+  // Check environment variables
+  for (const envVar of CLAUDE_INDICATORS.envVars) {
+    if (process.env[envVar]) {
+      return true;
+    }
+  }
+
+  // Check for Claude directories
+  for (const dir of CLAUDE_INDICATORS.directories) {
+    if (fs.existsSync(dir)) {
+      // Directory exists, check for recent session markers
+      const sessionMarker = path.join(dir, 'session', 'current', 'state.json');
+      if (fs.existsSync(sessionMarker)) {
+        try {
+          const state = JSON.parse(fs.readFileSync(sessionMarker, 'utf-8'));
+          // Check if session is recent (within last 24 hours)
+          if (state.startedAt) {
+            const sessionStart = new Date(state.startedAt);
+            const hoursSinceStart = (Date.now() - sessionStart.getTime()) / (1000 * 60 * 60);
+            if (hoursSinceStart < 24) {
+              return true;
+            }
+          }
+        } catch {
+          // Ignore parse errors
+        }
+      }
+      // Even without active session, presence of .claude indicates CLI usage
+      return true;
+    }
+  }
+
+  // Check for session files in current directory
+  for (const sessionFile of CLAUDE_INDICATORS.sessionFiles) {
+    if (fs.existsSync(path.join(process.cwd(), sessionFile))) {
+      return true;
+    }
+  }
+
+  // Check if we're in a TTY with Claude Code characteristics
+  if (process.stdout.isTTY) {
+    // Check for VS Code terminal (common Claude Code environment)
+    if (process.env.TERM_PROGRAM === 'vscode') {
+      return true;
+    }
+
+    // Check for Claude Code specific terminal markers
+    if (process.env.CLAUDE_CODE_TERMINAL === 'true') {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Check if API access is available
+ * @returns {boolean}
+ */
+function hasApiAccess() {
+  return !!(
+    process.env.ANTHROPIC_API_KEY ||
+    process.env.CLAUDE_API_KEY ||
+    process.env.CLAUDE_CODE_API_ACCESS === 'true'
+  );
+}
+
+/**
+ * Detect the current execution environment
+ * @returns {{mode: string, isClaudeCode: boolean, hasApiAccess: boolean, capabilities: string[], indicators: string[]}}
+ */
+function detectEnvironment() {
+  const result = {
+    isClaudeCode: false,
+    hasApiAccess: false,
+    mode: 'standalone',
+    capabilities: [],
+    indicators: []
+  };
+
+  // Check for Claude Code session
+  result.isClaudeCode = isClaudeCodeSession();
+
+  // Check for API access
+  result.hasApiAccess = hasApiAccess();
+
+  // Collect detected indicators for debugging
+  for (const envVar of CLAUDE_INDICATORS.envVars) {
+    if (process.env[envVar]) {
+      result.indicators.push(`env:${envVar}`);
+    }
+  }
+  for (const dir of CLAUDE_INDICATORS.directories) {
+    if (fs.existsSync(dir)) {
+      result.indicators.push(`dir:${path.basename(dir)}`);
+    }
+  }
+
+  // Determine mode based on detection
+  if (result.isClaudeCode && result.hasApiAccess) {
+    result.mode = 'full-ai';
+  } else if (result.isClaudeCode) {
+    result.mode = 'hybrid';
+  } else {
+    result.mode = 'standalone';
+  }
+
+  // Assign capabilities based on mode
+  result.capabilities = CAPABILITIES[result.mode] || CAPABILITIES.standalone;
+
+  return result;
+}
+
+/**
+ * Get a human-readable description of the environment
+ * @param {object} env - Environment detection result
+ * @returns {string}
+ */
+function getEnvironmentDescription(env) {
+  switch (env.mode) {
+    case 'full-ai':
+      return 'Claude Code session with AI analysis enabled';
+    case 'hybrid':
+      return 'Claude Code session (AI analysis available on next run)';
+    case 'standalone':
+      return 'Standalone mode (static analysis only)';
+    default:
+      return 'Unknown environment';
+  }
+}
+
+/**
+ * Check if a specific capability is available
+ * @param {object} env - Environment detection result
+ * @param {string} capability - Capability to check
+ * @returns {boolean}
+ */
+function hasCapability(env, capability) {
+  return env.capabilities.includes(capability);
+}
+
+/**
+ * Force a specific mode (for testing or CLI override)
+ * @param {string} mode - Mode to force ('full-ai', 'hybrid', 'standalone')
+ * @returns {object} Environment result with forced mode
+ */
+function forceMode(mode) {
+  if (!CAPABILITIES[mode]) {
+    throw new Error(`Invalid mode: ${mode}. Valid modes: ${Object.keys(CAPABILITIES).join(', ')}`);
+  }
+
+  return {
+    isClaudeCode: mode !== 'standalone',
+    hasApiAccess: mode === 'full-ai',
+    mode,
+    capabilities: CAPABILITIES[mode],
+    indicators: [`forced:${mode}`],
+    forced: true
+  };
+}
+
+module.exports = {
+  detectEnvironment,
+  isClaudeCodeSession,
+  hasApiAccess,
+  getEnvironmentDescription,
+  hasCapability,
+  forceMode,
+  CLAUDE_INDICATORS,
+  CAPABILITIES
+};

package/lib/index.js

@@ -5,10 +5,15 @@
  * 1. Interactive prompts (or defaults)
  * 2. Directory structure creation
  * 3. Template copying
- * 4. Tech stack detection
- * 5. Placeholder replacement
- * 6. Validation
- * 7. Plugin installation (optional)
+ * 4. Environment detection (Claude Code or standalone)
+ * 5. Tech stack detection
+ * 6. Deep codebase analysis
+ * 7. Template population with real data
+ * 8. Placeholder replacement
+ * 9. AI orchestration (if in Claude Code)
+ * 10. Validation
+ * 11. Plugin installation (optional)
+ * 12. Git initialization (optional)
  */
 
 const path = require('path');
@@ -25,6 +30,16 @@ const { detectTechStack } = require('./detector');
 const { replacePlaceholders } = require('./placeholder');
 const { validateInstallation } = require('./validate');
 
+// New modules for context engineering initialization
+const { detectEnvironment, forceMode, getEnvironmentDescription } = require('./environment-detector');
+const { analyzeCodebase } = require('./static-analyzer');
+const {
+  createInitializationRequest,
+  generateAgentInstructions,
+  isInitializationPending
+} = require('./ai-orchestrator');
+const { populateAllTemplates } = require('./template-populator');
+
 /**
  * Main entry point
  */
@@ -36,7 +51,11 @@ async function run(options = {}) {
     template,
     initGit = true,
     dryRun = false,
-    verbose = false
+    verbose = false,
+    // New options for context engineering
+    forceAi = false,
+    forceStatic = false,
+    analyzeOnly = false
   } = options;
 
   // Determine target directory
@@ -45,6 +64,7 @@ async function run(options = {}) {
     : process.cwd();
 
   const projectNameResolved = projectName || path.basename(targetDir);
+  const claudeDir = path.join(targetDir, '.claude');
 
   // Get configuration (prompts or defaults)
   let config;
@@ -76,35 +96,100 @@ async function run(options = {}) {
     spinner.succeed(`Created project directory: ${projectNameResolved}`);
   }
 
-  // Phase 2: Create .claude directory structure
+  // Phase 2: Detect execution environment
+  spinner.start('Detecting execution environment...');
+  let env;
+  if (forceAi) {
+    env = forceMode('full-ai');
+  } else if (forceStatic) {
+    env = forceMode('standalone');
+  } else {
+    env = detectEnvironment();
+  }
+  spinner.succeed(`Environment: ${getEnvironmentDescription(env)}`);
+
+  // Phase 3: Create .claude directory structure
   spinner.start('Creating .claude directory structure...');
   const dirsCreated = await createDirectoryStructure(targetDir, config);
   spinner.succeed(`Created .claude directory structure (${dirsCreated} directories)`);
 
-  // Phase 3: Copy template files
+  // Phase 4: Copy template files
   spinner.start('Copying template files...');
   const filesCopied = await copyTemplates(targetDir, config);
   spinner.succeed(`Copied ${filesCopied} template files`);
 
-  // Phase 4: Detect technology stack
+  // Phase 5: Detect technology stack
   spinner.start('Detecting technology stack...');
   const techStack = await detectTechStack(targetDir);
+  config.techStack = techStack;
   spinner.succeed(`Detected: ${techStack.summary || 'Generic project'}`);
 
-  // Phase 5: Replace placeholders
-  spinner.start('Populating templates with project info...');
+  // Phase 6: Deep codebase analysis
+  spinner.start('Analyzing codebase...');
+  let analysis;
+  try {
+    analysis = await analyzeCodebase(targetDir, { techStack });
+    const summary = analysis.summary || {};
+    spinner.succeed(
+      `Analyzed: ${summary.totalFiles || 0} files, ` +
+      `${summary.entryPointCount || 0} entry points, ` +
+      `${summary.workflowCount || 0} workflows`
+    );
+  } catch (error) {
+    spinner.warn(`Analysis partial: ${error.message}`);
+    analysis = { workflows: [], entryPoints: [], architecture: {}, techStack };
+  }
+
+  // Add tech stack to analysis
+  analysis.techStack = techStack;
+
+  // Phase 7: Create CLAUDE.md at root (before population)
+  spinner.start('Creating CLAUDE.md...');
+  await createClaudeMd(targetDir, config, techStack);
+  spinner.succeed('Created CLAUDE.md at project root');
+
+  // Phase 8: Populate templates with real data
+  spinner.start('Populating templates with analysis results...');
+  let populationResults;
+  try {
+    populationResults = await populateAllTemplates(claudeDir, analysis, config);
+    const counts = {
+      populated: populationResults.populated?.length || 0,
+      created: populationResults.created?.length || 0,
+      errors: populationResults.errors?.length || 0
+    };
+    if (counts.errors > 0) {
+      spinner.warn(`Populated ${counts.populated} files, created ${counts.created} workflows (${counts.errors} errors)`);
+    } else {
+      spinner.succeed(`Populated ${counts.populated} files, created ${counts.created} workflow docs`);
+    }
+  } catch (error) {
+    spinner.warn(`Population partial: ${error.message}`);
+    populationResults = { populated: [], created: [], errors: [error.message] };
+  }
+
+  // Phase 9: Replace remaining placeholders
+  spinner.start('Replacing remaining placeholders...');
   const placeholdersReplaced = await replacePlaceholders(targetDir, {
     ...config,
-    techStack
+    techStack,
+    analysis
   });
   spinner.succeed(`Replaced ${placeholdersReplaced} placeholders`);
 
-  // Phase 6: Create CLAUDE.md at root
-  spinner.start('Creating CLAUDE.md...');
-  await createClaudeMd(targetDir, config, techStack);
-  spinner.succeed('Created CLAUDE.md at project root');
+  // Phase 10: AI Orchestration (if in Claude Code environment)
+  if (env.mode === 'full-ai' || env.mode === 'hybrid') {
+    spinner.start('Preparing AI initialization request...');
+    try {
+      createInitializationRequest(claudeDir, config);
+      generateAgentInstructions(claudeDir, analysis, config);
+      spinner.succeed('Created INIT_REQUEST.md for @context-engineer');
+    } catch (error) {
+      spinner.warn(`AI setup skipped: ${error.message}`);
+    }
+  }
 
-  // Phase 7: Validate installation
+  // Phase 11: Validate installation
   spinner.start('Validating installation...');
   const validation = await validateInstallation(targetDir);
   if (validation.passed) {
@@ -113,15 +198,13 @@ async function run(options = {}) {
     spinner.warn(`Validation completed with ${validation.warnings} warnings`);
   }
 
-  // Phase 8: Install Claude Code plugin (optional)
+  // Phase 12: Install Claude Code plugin (optional)
   if (config.installPlugin) {
     spinner.start('Installing Claude Code plugin...');
-    // Plugin installation would use: npx claude-plugins install claude-context-engineering
-    // For now, we'll note it as a next step
     spinner.succeed('Plugin ready (install with: /plugin install claude-context-engineering)');
   }
 
-  // Phase 9: Initialize git (optional)
+  // Phase 13: Initialize git (optional)
   if (config.initGit && !fs.existsSync(path.join(targetDir, '.git'))) {
     spinner.start('Initializing git repository...');
     try {
@@ -133,37 +216,55 @@ async function run(options = {}) {
     }
   }
 
-  // Success message
-  showSuccess(config, techStack);
+  // Success message (mode-aware)
+  showSuccess(config, techStack, env, analysis, populationResults);
 }
 
 /**
  * Display success message with next steps
  */
-function showSuccess(config, techStack) {
+function showSuccess(config, techStack, env, analysis, populationResults) {
   const boxWidth = 59;
+  const isAiMode = env.mode === 'full-ai' || env.mode === 'hybrid';
+  const workflowCount = analysis?.workflows?.length || 0;
+  const entryPointCount = analysis?.entryPoints?.length || 0;
 
   console.log(`
 ${chalk.green('╔' + '═'.repeat(boxWidth) + '╗')}
 ${chalk.green('║')}  ${chalk.bold.white('✓ Context Engineering Initialized Successfully!')}        ${chalk.green('║')}
 ${chalk.green('╚' + '═'.repeat(boxWidth) + '╝')}
 
+${chalk.bold('Analysis Results:')}
+  ${chalk.cyan('•')} Entry Points:    ${chalk.white(entryPointCount)} discovered
+  ${chalk.cyan('•')} Workflows:       ${chalk.white(workflowCount)} documented
+  ${chalk.cyan('•')} Mode:            ${chalk.white(env.mode)}
+
 ${chalk.bold('Created:')}
   ${chalk.cyan('•')} .claude/          ${chalk.gray('(context engineering system)')}
   ${chalk.cyan('•')} CLAUDE.md         ${chalk.gray('(AI navigation guide)')}
+${workflowCount > 0 ? `  ${chalk.cyan('•')} ${workflowCount} workflow docs  ${chalk.gray('(auto-generated)')}` : ''}
 
 ${chalk.bold('Available Commands:')}
   ${chalk.cyan('•')} /rpi-research     ${chalk.gray('Research a feature')}
   ${chalk.cyan('•')} /rpi-plan         ${chalk.gray('Create implementation plan')}
   ${chalk.cyan('•')} /rpi-implement    ${chalk.gray('Execute with documentation')}
   ${chalk.cyan('•')} /validate-all     ${chalk.gray('Run validation suite')}
+`);
 
-${chalk.bold('Next Steps:')}
+  if (isAiMode) {
+    console.log(`${chalk.bold.yellow('AI Initialization Pending:')}
+  ${chalk.white('Run this command in Claude Code to complete:')}
+  ${chalk.cyan('@context-engineer "Complete initialization using INIT_REQUEST.md"')}
+`);
+  } else {
+    console.log(`${chalk.bold('Next Steps:')}
   ${chalk.white('1.')} Review ${chalk.cyan('CLAUDE.md')} and customize for your project
-  ${chalk.white('2.')} Run: ${chalk.cyan('@context-engineer "Discover workflows for this codebase"')}
-  ${chalk.white('3.')} Use ${chalk.cyan('/rpi-research')} for your first feature
+  ${chalk.white('2.')} Review generated workflow docs in ${chalk.cyan('.claude/context/workflows/')}
+  ${chalk.white('3.')} Run ${chalk.cyan('@context-engineer "Enhance documentation"')} for AI analysis
+`);
+  }
 
-${chalk.gray('Documentation: https://github.com/SireJeff/claude-context-engineering-template')}
+  console.log(`${chalk.gray('Documentation: https://github.com/SireJeff/claude-context-engineering-template')}
 `);
 }
 

package/lib/placeholder.js

@@ -50,9 +50,9 @@ const KNOWN_PLACEHOLDERS = {
 };
 
 /**
- * Get default placeholder values based on config and tech stack
+ * Get default placeholder values based on config, tech stack, and analysis
  */
-function getDefaultValues(config = {}, techStack = {}) {
+function getDefaultValues(config = {}, techStack = {}, analysis = {}) {
   const today = new Date().toISOString().split('T')[0];
   const projectName = config.projectName || 'my-project';
 
@@ -61,34 +61,60 @@ function getDefaultValues(config = {}, techStack = {}) {
     install: 'npm install',
     dev: 'npm run dev',
     test: 'npm test',
-    migrate: 'npm run migrate'
+    testE2e: 'npm run test:e2e',
+    testCoverage: 'npm run test:coverage',
+    migrateCreate: 'npm run migration:create',
+    migrateRun: 'npm run migration:run',
+    deploy: 'npm run deploy'
   };
 
   if (techStack.commands) {
-    commands = techStack.commands;
+    commands = { ...commands, ...techStack.commands };
   } else if (techStack.languages?.includes('python')) {
     commands = {
       install: 'pip install -r requirements.txt',
       dev: 'python main.py',
       test: 'pytest',
-      migrate: 'alembic upgrade head'
+      testE2e: 'pytest tests/e2e/',
+      testCoverage: 'pytest --cov',
+      migrateCreate: 'alembic revision --autogenerate',
+      migrateRun: 'alembic upgrade head',
+      deploy: 'docker-compose up -d'
     };
   } else if (techStack.languages?.includes('go')) {
     commands = {
       install: 'go mod download',
       dev: 'go run .',
       test: 'go test ./...',
-      migrate: 'migrate -path migrations up'
+      testE2e: 'go test ./e2e/...',
+      testCoverage: 'go test -cover ./...',
+      migrateCreate: 'migrate create -ext sql',
+      migrateRun: 'migrate -path migrations up',
+      deploy: 'docker-compose up -d'
     };
   } else if (techStack.languages?.includes('rust')) {
     commands = {
       install: 'cargo build',
       dev: 'cargo run',
       test: 'cargo test',
-      migrate: 'sqlx migrate run'
+      testE2e: 'cargo test --test e2e',
+      testCoverage: 'cargo tarpaulin',
+      migrateCreate: 'sqlx migrate add',
+      migrateRun: 'sqlx migrate run',
+      deploy: 'cargo build --release'
     };
   }
 
+  // Build core files list from analysis
+  let coreFilesList = '- src/\n- config/';
+  if (analysis.entryPoints && analysis.entryPoints.length > 0) {
+    const uniqueFiles = [...new Set(analysis.entryPoints.map(e => e.file))];
+    coreFilesList = uniqueFiles.slice(0, 10).map(f => `- \`${f}\``).join('\n');
+  }
+
+  // Get workflow count from analysis
+  const workflowCount = analysis.workflows?.length || 0;
+
   return {
     PROJECT_NAME: projectName,
     PROJECT_DESCRIPTION: `${projectName} application`,
@@ -97,23 +123,58 @@ function getDefaultValues(config = {}, techStack = {}) {
     PROJECT_STATUS: 'Development',
     API_URL: `https://api.${projectName}.example.com`,
     REPO_URL: `https://github.com/user/${projectName}`,
-    DEPLOYMENT_PLATFORM: 'Docker',
+    DEPLOYMENT_PLATFORM: 'TBD',
     INSTALL_COMMAND: commands.install,
     DEV_START_COMMAND: commands.dev,
     TEST_COMMAND: commands.test,
-    TEST_E2E_COMMAND: `${commands.test} --e2e`,
-    TEST_COVERAGE_COMMAND: `${commands.test} --coverage`,
-    MIGRATION_CREATE_COMMAND: `${commands.migrate}:create`,
-    MIGRATION_RUN_COMMAND: commands.migrate,
-    DEPLOY_COMMAND: 'docker-compose up -d',
-    MODELS_PATH: 'src/models/',
-    MIGRATIONS_PATH: 'src/migrations/',
-    CORE_FILES_LIST: '- src/\n- config/',
-    WORKFLOWS_COUNT: '8',
+    TEST_E2E_COMMAND: commands.testE2e,
+    TEST_COVERAGE_COMMAND: commands.testCoverage,
+    MIGRATION_CREATE_COMMAND: commands.migrateCreate,
+    MIGRATION_RUN_COMMAND: commands.migrateRun,
+    DEPLOY_COMMAND: commands.deploy,
+    MODELS_PATH: 'models/',
+    MIGRATIONS_PATH: 'migrations/',
+    CORE_FILES_LIST: coreFilesList,
+    WORKFLOWS_COUNT: String(workflowCount),
+    WORKFLOW_DOMAINS_COUNT: String(workflowCount > 0 ? Math.min(workflowCount, 5) : 0),
+    CODE_DOMAINS_COUNT: '0',
     AGENTS_COUNT: '6',
-    COMMANDS_COUNT: '8',
+    COMMANDS_COUNT: '11',
+    INDEX_FILES_COUNT: '15',
     DATE: today,
     AGENT_TABLE_ROWS: '',
+    AGENT_ROUTING_TABLE: '@context-engineer for setup, @core-architect for design',
+    DEBUGGING_QUICK_REFS: 'KNOWN_GOTCHAS.md, logs/',
+    EXAMPLE_REFACTOR_TASK: 'Refactor the authentication flow',
+    EXAMPLE_LOWLEVEL_TASK: 'Fix hardcoded API URL in config',
+    EXAMPLE_FEATURE_TASK: 'Add user notifications feature',
+    CONFIG_SEARCH_PATTERN: 'grep -r "process.env" --include="*.js" --include="*.ts"',
+    URL_SEARCH_PATTERN: 'grep -rE "https?://" --include="*.js" --include="*.ts" --include="*.json"',
+    EXTERNAL_INTEGRATIONS_LIST: '*No external integrations detected. Document manually if present.*',
+    ARCHITECTURE_DIAGRAM: `┌─────────────────────────────────────┐
+│           [Application]             │
+│                                     │
+│   ┌───────────┐   ┌───────────┐    │
+│   │   API     │   │  Services │    │
+│   └───────────┘   └───────────┘    │
+│                                     │
+│   ┌───────────┐   ┌───────────┐    │
+│   │  Models   │   │ Database  │    │
+│   └───────────┘   └───────────┘    │
+└─────────────────────────────────────┘`,
+    CRITICAL_URLS: `- Production: https://${projectName}.example.com`,
+    BUSINESS_CONSTANTS: '- TBD (document key business constants)',
+    GOTCHA_CATEGORY_1: 'Database',
+    GOTCHA_1_ITEMS: '- TBD (document database gotchas)',
+    GOTCHA_CATEGORY_2: 'API',
+    GOTCHA_2_ITEMS: '- TBD (document API gotchas)',
+    PRODUCTION_PLATFORM: 'TBD',
+    PRODUCTION_SERVICES: 'Web, API, Database',
+    MONITORING_COMMANDS: 'Check logs, health endpoints',
+    MIGRATION_CONSTRAINTS: 'Always backup before migrations',
+    TESTING_CONSTRAINTS: 'Run tests before merging',
+    SECURITY_CONSTRAINTS: 'Never commit secrets',
+    CONTACT_INFO: 'TBD (add contact info)',
   };
 }
 
@@ -122,7 +183,7 @@ function getDefaultValues(config = {}, techStack = {}) {
  */
 async function replacePlaceholders(targetDir, config = {}) {
   const claudeDir = path.join(targetDir, '.claude');
-  const values = getDefaultValues(config, config.techStack || {});
+  const values = getDefaultValues(config, config.techStack || {}, config.analysis || {});
 
   // Find all markdown and JSON files
   const files = await glob('**/*.{md,json}', {