claude-brain 0.30.2 → 0.30.3

package/src/server/handlers/tools/init-project.ts

@@ -1,756 +1,756 @@
-/**
- * Init Project Handler
- * Analyzes an existing codebase and creates project in vault
- * Similar to `claude init` - reads files to extract project info
- */
-
-import type { Logger } from 'pino'
-import type { ToolResponse } from '@/tools/types'
-import { getVaultService, getMemoryService, isServicesInitialized } from '@/server/services'
-import { ResponseFormatter } from '@/server/utils/response-formatter'
-import { ErrorHandler } from '@/server/utils/error-handler'
-import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js'
-import { PackManager, PackLoader, type PackLoadResult } from '@/packs/index'
-import fs from 'fs/promises'
-import path from 'path'
-import { fileURLToPath } from 'node:url'
-import { dirname, resolve } from 'node:path'
-
-interface InitProjectInput {
-  project_path?: string
-  project_name?: string
-  save_to_memory?: boolean
-}
-
-interface ProjectAnalysis {
-  name: string
-  description: string
-  techStack: string[]
-  frameworks: string[]
-  languages: string[]
-  packageManager: string | null
-  structure: string[]
-  keyFiles: string[]
-  scripts: Record<string, string>
-  dependencies: string[]
-  devDependencies: string[]
-  hasTests: boolean
-  hasTypeScript: boolean
-  hasLinting: boolean
-  hasFormatting: boolean
-  gitIgnorePatterns: string[]
-  conventions: string[]
-}
-
-export async function handleInitProject(
-  args: unknown,
-  logger: Logger
-): Promise<ToolResponse> {
-  try {
-    const input = args as InitProjectInput
-    const {
-      project_path = process.cwd(),
-      project_name,
-      save_to_memory = true
-    } = input
-
-    logger.info({ project_path, project_name }, 'Initializing project analysis')
-
-    if (!isServicesInitialized()) {
-      throw new McpError(
-        ErrorCode.InternalError,
-        'Services not initialized'
-      )
-    }
-
-    // Verify path exists
-    try {
-      const stats = await fs.stat(project_path)
-      if (!stats.isDirectory()) {
-        throw new McpError(
-          ErrorCode.InvalidParams,
-          `Path is not a directory: ${project_path}`
-        )
-      }
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-        throw new McpError(
-          ErrorCode.InvalidParams,
-          `Directory not found: ${project_path}`
-        )
-      }
-      throw error
-    }
-
-    // Analyze the project
-    const analysis = await analyzeProject(project_path, logger)
-
-    // Use provided name or detected name
-    const finalName = project_name || analysis.name
-    const normalizedName = finalName
-      .toLowerCase()
-      .replace(/\s+/g, '-')
-      .replace(/[^a-z0-9-]/g, '')
-
-    if (!normalizedName || normalizedName.length < 2) {
-      throw new McpError(
-        ErrorCode.InvalidParams,
-        'Could not determine project name. Please provide project_name parameter.'
-      )
-    }
-
-    const vault = getVaultService()
-
-    // Check if project already exists
-    const existingProjects = await vault.listProjects()
-    const projectExists = existingProjects.includes(normalizedName)
-
-    if (!projectExists) {
-      // Create new project
-      await vault.createProject(normalizedName)
-    }
-
-    // Update project files with analysis
-    const projectPaths = vault.getProjectPaths(normalizedName)
-
-    // Update context.md
-    const contextContent = generateContextContent(analysis)
-    await vault.writer.writeMarkdownFile(
-      projectPaths.context,
-      {
-        type: 'project-context',
-        project: normalizedName,
-        status: 'active',
-        created: new Date().toISOString().split('T')[0],
-        updated: new Date().toISOString().split('T')[0],
-        tech_stack: analysis.techStack,
-        languages: analysis.languages,
-        frameworks: analysis.frameworks,
-        tags: detectTags(analysis),
-        description: analysis.description,
-        analyzed_from: project_path
-      },
-      contextContent,
-      { createBackup: projectExists }
-    )
-
-    // Update standards.md
-    const standardsContent = generateStandardsContent(analysis)
-    await vault.writer.writeMarkdownFile(
-      projectPaths.standards,
-      {
-        type: 'coding-standards',
-        project: normalizedName,
-        languages: analysis.languages,
-        frameworks: analysis.frameworks,
-        last_updated: new Date().toISOString().split('T')[0]
-      },
-      standardsContent,
-      { createBackup: projectExists }
-    )
-
-    // Save to memory for semantic search
-    if (save_to_memory) {
-      const memory = getMemoryService()
-
-      // Store project overview as a decision/context
-      const projectSummary = `
-Project: ${normalizedName}
-Description: ${analysis.description}
-Tech Stack: ${analysis.techStack.join(', ')}
-Languages: ${analysis.languages.join(', ')}
-Frameworks: ${analysis.frameworks.join(', ')}
-Key Files: ${analysis.keyFiles.join(', ')}
-Has Tests: ${analysis.hasTests}
-Has TypeScript: ${analysis.hasTypeScript}
-`.trim()
-
-      await memory.rememberDecision(
-        normalizedName,
-        'Project initialization and setup',
-        `Initialized ${normalizedName} with Claude Brain`,
-        projectSummary,
-        {
-          tags: ['project-init', 'setup', ...analysis.languages, ...analysis.frameworks]
-        }
-      )
-
-      logger.info({ normalizedName }, 'Project saved to memory')
-    }
-
-    // Phase 18: Load knowledge packs based on detected tech stack
-    let packResult: PackLoadResult | null = null
-    try {
-      const initFile = fileURLToPath(import.meta.url)
-      const initDir = dirname(initFile)
-      const PACKAGE_ROOT = resolve(initDir, '..', '..', '..', '..')
-      const dataDir = path.join(process.env.CLAUDE_BRAIN_HOME || path.join(process.env.HOME || '~', '.claude-brain'), 'data')
-
-      // Default packs config
-      const packsConfig = {
-        enabled: true,
-        packsDir: 'packs',
-        alwaysLoadCore: true,
-        alwaysLoadMeta: true,
-        communityConfidenceMultiplier: 0.8,
-        personalBoost: 1.2,
-        projectBoost: 1.15
-      }
-
-      if (packsConfig.enabled) {
-        const memory = getMemoryService()
-        const packManager = new PackManager(logger, packsConfig, PACKAGE_ROOT, dataDir)
-        const packLoader = new PackLoader(logger, memory, packManager, packsConfig)
-        packResult = await packLoader.loadPacksForProject(normalizedName, analysis.techStack)
-        logger.info({ packResult }, 'Knowledge packs loaded')
-      }
-    } catch (packError) {
-      logger.warn({ error: packError }, 'Pack loading failed (non-blocking)')
-    }
-
-    // Build response
-    const parts: string[] = []
-    parts.push(`## ${projectExists ? '🔄 Project Updated' : '✅ Project Initialized'}: ${normalizedName}\n`)
-
-    parts.push(`### Analysis Results\n`)
-    parts.push(`**Source:** \`${project_path}\`\n`)
-
-    if (analysis.description) {
-      parts.push(`**Description:** ${analysis.description}\n`)
-    }
-
-    parts.push(`\n### Tech Stack`)
-    parts.push(`- **Languages:** ${analysis.languages.join(', ') || 'Not detected'}`)
-    parts.push(`- **Frameworks:** ${analysis.frameworks.join(', ') || 'Not detected'}`)
-    parts.push(`- **Package Manager:** ${analysis.packageManager || 'Not detected'}`)
-
-    parts.push(`\n### Project Features`)
-    parts.push(`- TypeScript: ${analysis.hasTypeScript ? '✅' : '❌'}`)
-    parts.push(`- Tests: ${analysis.hasTests ? '✅' : '❌'}`)
-    parts.push(`- Linting: ${analysis.hasLinting ? '✅' : '❌'}`)
-    parts.push(`- Formatting: ${analysis.hasFormatting ? '✅' : '❌'}`)
-
-    if (analysis.keyFiles.length > 0) {
-      parts.push(`\n### Key Files Detected`)
-      analysis.keyFiles.slice(0, 10).forEach(f => parts.push(`- \`${f}\``))
-    }
-
-    if (Object.keys(analysis.scripts).length > 0) {
-      parts.push(`\n### Available Scripts`)
-      Object.entries(analysis.scripts).slice(0, 8).forEach(([name, cmd]) => {
-        parts.push(`- \`${name}\`: ${cmd.slice(0, 50)}${cmd.length > 50 ? '...' : ''}`)
-      })
-    }
-
-    if (analysis.conventions.length > 0) {
-      parts.push(`\n### Detected Conventions`)
-      analysis.conventions.forEach(c => parts.push(`- ${c}`))
-    }
-
-    parts.push(`\n### Files Created/Updated`)
-    parts.push(`- \`${normalizedName}/context.md\` - Project overview`)
-    parts.push(`- \`${normalizedName}/standards.md\` - Coding standards`)
-    parts.push(`- \`${normalizedName}/progress.md\` - Progress tracking`)
-    parts.push(`- \`${normalizedName}/decisions.md\` - Decision log`)
-
-    if (save_to_memory) {
-      parts.push(`\n### Memory`)
-      parts.push(`Project context saved to semantic memory for future recall.`)
-    }
-
-    if (packResult && packResult.packsLoaded > 0) {
-      parts.push(`\n### Knowledge Packs`)
-      parts.push(`Loaded **${packResult.packsLoaded}** pack(s) with **${packResult.entriesLoaded}** entries:`)
-      for (const detail of packResult.packDetails) {
-        parts.push(`- **${detail.name}** (${detail.entriesLoaded} entries)`)
-      }
-      if (packResult.skipped.length > 0) {
-        parts.push(`\nSkipped: ${packResult.skipped.map(s => `${s.packId} (${s.reason})`).join(', ')}`)
-      }
-    } else if (packResult && packResult.skipped.length > 0) {
-      parts.push(`\n### Knowledge Packs`)
-      parts.push(`All packs already loaded (${packResult.skipped.length} skipped).`)
-    }
-
-    parts.push(`\n### Next Steps`)
-    parts.push(`1. Use \`get_project_context("${normalizedName}")\` to view full context`)
-    parts.push(`2. Use \`remember_decision\` to save architectural decisions`)
-    parts.push(`3. Use \`recall_similar\` to search past decisions`)
-
-    logger.info({
-      project: normalizedName,
-      techStack: analysis.techStack,
-      isNew: !projectExists
-    }, 'Project initialized successfully')
-
-    return ResponseFormatter.text(parts.join('\n'))
-
-  } catch (error) {
-    ErrorHandler.logError(logger, error, { tool: 'init_project', args })
-
-    if (error instanceof McpError) {
-      throw error
-    }
-
-    // Provide detailed error message
-    if (error instanceof Error) {
-      let errorMsg = `Failed to initialize project: ${error.message}\n\n`
-
-      // Add specific troubleshooting steps based on error type
-      if (error.message.includes('EACCES') || error.message.includes('permission')) {
-        errorMsg += `**Permission Error**\n` +
-          `- Check that you have read/write permissions for the project directory\n` +
-          `- Ensure the Obsidian vault path is writable\n`
-      } else if (error.message.includes('ENOENT')) {
-        errorMsg += `**File Not Found**\n` +
-          `- Verify the project_path exists\n` +
-          `- Check that the path is absolute, not relative\n`
-      } else if (error.message.includes('parse') || error.message.includes('JSON')) {
-        errorMsg += `**Parse Error**\n` +
-          `- package.json or other config files may be malformed\n` +
-          `- Check for syntax errors in configuration files\n`
-      } else {
-        errorMsg += `**Troubleshooting:**\n` +
-          `- Ensure the directory exists and is accessible\n` +
-          `- Check file permissions in both project and vault directories\n` +
-          `- Verify config files (package.json, etc.) are valid\n`
-      }
-
-      errorMsg += `\n**Error details:** ${error.stack || error.message}`
-
-      throw new McpError(ErrorCode.InternalError, errorMsg)
-    }
-
-    throw new McpError(
-      ErrorCode.InternalError,
-      `Failed to initialize project: Unknown error occurred`
-    )
-  }
-}
-
-/**
- * Analyze project directory
- */
-async function analyzeProject(projectPath: string, logger: Logger): Promise<ProjectAnalysis> {
-  const analysis: ProjectAnalysis = {
-    name: path.basename(projectPath),
-    description: '',
-    techStack: [],
-    frameworks: [],
-    languages: [],
-    packageManager: null,
-    structure: [],
-    keyFiles: [],
-    scripts: {},
-    dependencies: [],
-    devDependencies: [],
-    hasTests: false,
-    hasTypeScript: false,
-    hasLinting: false,
-    hasFormatting: false,
-    gitIgnorePatterns: [],
-    conventions: []
-  }
-
-  // Read directory structure (top level + 1 deep)
-  try {
-    const entries = await fs.readdir(projectPath, { withFileTypes: true })
-
-    for (const entry of entries) {
-      if (entry.name.startsWith('.') && entry.name !== '.eslintrc.json' && entry.name !== '.prettierrc') {
-        continue
-      }
-
-      if (entry.isDirectory()) {
-        analysis.structure.push(`${entry.name}/`)
-      } else {
-        analysis.structure.push(entry.name)
-      }
-    }
-  } catch (error) {
-    logger.warn({ error }, 'Failed to read directory structure')
-  }
-
-  // Check for package.json (Node.js/JavaScript projects)
-  await analyzePackageJson(projectPath, analysis, logger)
-
-  // Check for other config files
-  await analyzeConfigFiles(projectPath, analysis, logger)
-
-  // Check for Python projects
-  await analyzePythonProject(projectPath, analysis, logger)
-
-  // Check for Go projects
-  await analyzeGoProject(projectPath, analysis, logger)
-
-  // Check for Rust projects
-  await analyzeRustProject(projectPath, analysis, logger)
-
-  // Detect test directories
-  await detectTests(projectPath, analysis, logger)
-
-  // Read README for description
-  await readReadme(projectPath, analysis, logger)
-
-  // Read .gitignore
-  await readGitignore(projectPath, analysis, logger)
-
-  // Detect conventions from structure
-  detectConventions(analysis)
-
-  // Build final tech stack
-  analysis.techStack = [...new Set([...analysis.languages, ...analysis.frameworks])]
-
-  return analysis
-}
-
-async function analyzePackageJson(projectPath: string, analysis: ProjectAnalysis, _logger: Logger) {
-  try {
-    const pkgPath = path.join(projectPath, 'package.json')
-    const content = await fs.readFile(pkgPath, 'utf-8')
-    const pkg = JSON.parse(content)
-
-    analysis.name = pkg.name || analysis.name
-    analysis.description = pkg.description || ''
-    analysis.scripts = pkg.scripts || {}
-
-    // Detect package manager
-    if (await fileExists(path.join(projectPath, 'bun.lockb'))) {
-      analysis.packageManager = 'bun'
-    } else if (await fileExists(path.join(projectPath, 'pnpm-lock.yaml'))) {
-      analysis.packageManager = 'pnpm'
-    } else if (await fileExists(path.join(projectPath, 'yarn.lock'))) {
-      analysis.packageManager = 'yarn'
-    } else if (await fileExists(path.join(projectPath, 'package-lock.json'))) {
-      analysis.packageManager = 'npm'
-    }
-
-    // Languages
-    analysis.languages.push('javascript')
-
-    // Analyze dependencies
-    const allDeps = {
-      ...pkg.dependencies,
-      ...pkg.devDependencies
-    }
-
-    analysis.dependencies = Object.keys(pkg.dependencies || {})
-    analysis.devDependencies = Object.keys(pkg.devDependencies || {})
-
-    // Detect frameworks
-    if (allDeps['react']) {
-      analysis.frameworks.push('react')
-      if (allDeps['next']) analysis.frameworks.push('next.js')
-      if (allDeps['gatsby']) analysis.frameworks.push('gatsby')
-      if (allDeps['remix']) analysis.frameworks.push('remix')
-    }
-    if (allDeps['vue']) analysis.frameworks.push('vue')
-    if (allDeps['@angular/core']) analysis.frameworks.push('angular')
-    if (allDeps['svelte']) analysis.frameworks.push('svelte')
-    if (allDeps['express']) analysis.frameworks.push('express')
-    if (allDeps['fastify']) analysis.frameworks.push('fastify')
-    if (allDeps['hono']) analysis.frameworks.push('hono')
-    if (allDeps['elysia']) analysis.frameworks.push('elysia')
-    if (allDeps['nestjs'] || allDeps['@nestjs/core']) analysis.frameworks.push('nestjs')
-    if (allDeps['electron']) analysis.frameworks.push('electron')
-    if (allDeps['tauri']) analysis.frameworks.push('tauri')
-
-    // Detect TypeScript
-    if (allDeps['typescript'] || await fileExists(path.join(projectPath, 'tsconfig.json'))) {
-      analysis.hasTypeScript = true
-      analysis.languages.push('typescript')
-    }
-
-    // Detect testing
-    if (allDeps['jest'] || allDeps['vitest'] || allDeps['mocha'] || allDeps['ava']) {
-      analysis.hasTests = true
-    }
-
-    // Detect linting
-    if (allDeps['eslint'] || allDeps['biome'] || allDeps['@biomejs/biome']) {
-      analysis.hasLinting = true
-    }
-
-    // Detect formatting
-    if (allDeps['prettier'] || allDeps['biome'] || allDeps['@biomejs/biome']) {
-      analysis.hasFormatting = true
-    }
-
-    // Key files
-    analysis.keyFiles.push('package.json')
-
-  } catch (error) {
-    // Not a Node.js project
-  }
-}
-
-async function analyzeConfigFiles(projectPath: string, analysis: ProjectAnalysis, _logger: Logger) {
-  const configFiles = [
-    'tsconfig.json',
-    '.eslintrc.json',
-    '.eslintrc.js',
-    '.prettierrc',
-    'prettier.config.js',
-    'vite.config.ts',
-    'vite.config.js',
-    'webpack.config.js',
-    'rollup.config.js',
-    'tailwind.config.js',
-    'tailwind.config.ts',
-    'postcss.config.js',
-    'next.config.js',
-    'next.config.ts',
-    'nuxt.config.ts',
-    'astro.config.mjs',
-    'svelte.config.js',
-    'biome.json'
-  ]
-
-  for (const file of configFiles) {
-    if (await fileExists(path.join(projectPath, file))) {
-      analysis.keyFiles.push(file)
-
-      // Detect specific tools
-      if (file.includes('tailwind')) analysis.frameworks.push('tailwindcss')
-      if (file.includes('vite')) analysis.frameworks.push('vite')
-      if (file.includes('webpack')) analysis.frameworks.push('webpack')
-      if (file.includes('astro')) analysis.frameworks.push('astro')
-    }
-  }
-}
-
-async function analyzePythonProject(projectPath: string, analysis: ProjectAnalysis, _logger: Logger) {
-  // Check for Python files
-  if (await fileExists(path.join(projectPath, 'requirements.txt')) ||
-      await fileExists(path.join(projectPath, 'pyproject.toml')) ||
-      await fileExists(path.join(projectPath, 'setup.py'))) {
-
-    analysis.languages.push('python')
-
-    if (await fileExists(path.join(projectPath, 'requirements.txt'))) {
-      analysis.keyFiles.push('requirements.txt')
-      analysis.packageManager = 'pip'
-    }
-
-    if (await fileExists(path.join(projectPath, 'pyproject.toml'))) {
-      analysis.keyFiles.push('pyproject.toml')
-      analysis.packageManager = 'poetry'
-    }
-
-    // Check for frameworks
-    try {
-      const reqPath = path.join(projectPath, 'requirements.txt')
-      if (await fileExists(reqPath)) {
-        const content = await fs.readFile(reqPath, 'utf-8')
-        if (content.includes('django')) analysis.frameworks.push('django')
-        if (content.includes('flask')) analysis.frameworks.push('flask')
-        if (content.includes('fastapi')) analysis.frameworks.push('fastapi')
-        if (content.includes('pytest')) analysis.hasTests = true
-      }
-    } catch {}
-  }
-}
-
-async function analyzeGoProject(projectPath: string, analysis: ProjectAnalysis, _logger: Logger) {
-  if (await fileExists(path.join(projectPath, 'go.mod'))) {
-    analysis.languages.push('go')
-    analysis.keyFiles.push('go.mod')
-    analysis.packageManager = 'go modules'
-  }
-}
-
-async function analyzeRustProject(projectPath: string, analysis: ProjectAnalysis, _logger: Logger) {
-  if (await fileExists(path.join(projectPath, 'Cargo.toml'))) {
-    analysis.languages.push('rust')
-    analysis.keyFiles.push('Cargo.toml')
-    analysis.packageManager = 'cargo'
-  }
-}
-
-async function detectTests(projectPath: string, analysis: ProjectAnalysis, _logger: Logger) {
-  const testDirs = ['test', 'tests', '__tests__', 'spec', 'specs']
-
-  for (const dir of testDirs) {
-    if (await fileExists(path.join(projectPath, dir))) {
-      analysis.hasTests = true
-      analysis.keyFiles.push(`${dir}/`)
-      break
-    }
-  }
-}
-
-async function readReadme(projectPath: string, analysis: ProjectAnalysis, _logger: Logger) {
-  const readmeFiles = ['README.md', 'readme.md', 'Readme.md', 'README.txt', 'README']
-
-  for (const file of readmeFiles) {
-    try {
-      const content = await fs.readFile(path.join(projectPath, file), 'utf-8')
-      analysis.keyFiles.push(file)
-
-      // Extract first paragraph as description if not set
-      if (!analysis.description) {
-        const lines = content.split('\n')
-        for (const line of lines) {
-          const trimmed = line.trim()
-          // Skip headers and empty lines
-          if (trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('!') && trimmed.length > 20) {
-            analysis.description = trimmed.slice(0, 200)
-            break
-          }
-        }
-      }
-      break
-    } catch {}
-  }
-}
-
-async function readGitignore(projectPath: string, analysis: ProjectAnalysis, _logger: Logger) {
-  try {
-    const content = await fs.readFile(path.join(projectPath, '.gitignore'), 'utf-8')
-    analysis.gitIgnorePatterns = content
-      .split('\n')
-      .filter(line => line.trim() && !line.startsWith('#'))
-      .slice(0, 20)
-  } catch {}
-}
-
-function detectConventions(analysis: ProjectAnalysis) {
-  // Detect conventions based on structure and config
-
-  if (analysis.structure.includes('src/')) {
-    analysis.conventions.push('Source code in src/ directory')
-  }
-
-  if (analysis.structure.includes('lib/')) {
-    analysis.conventions.push('Library code in lib/ directory')
-  }
-
-  if (analysis.structure.includes('components/') || analysis.structure.some(s => s.includes('components'))) {
-    analysis.conventions.push('Component-based architecture')
-  }
-
-  if (analysis.hasTypeScript) {
-    analysis.conventions.push('TypeScript for type safety')
-  }
-
-  if (analysis.hasLinting) {
-    analysis.conventions.push('Code linting enforced')
-  }
-
-  if (analysis.hasFormatting) {
-    analysis.conventions.push('Code formatting enforced')
-  }
-
-  if (analysis.hasTests) {
-    analysis.conventions.push('Test coverage expected')
-  }
-
-  if (analysis.frameworks.includes('tailwindcss')) {
-    analysis.conventions.push('Tailwind CSS for styling')
-  }
-}
-
-function detectTags(analysis: ProjectAnalysis): string[] {
-  const tags: string[] = []
-
-  if (analysis.frameworks.some(f => ['react', 'vue', 'angular', 'svelte'].includes(f))) {
-    tags.push('frontend')
-  }
-
-  if (analysis.frameworks.some(f => ['express', 'fastify', 'nestjs', 'hono', 'elysia'].includes(f))) {
-    tags.push('backend')
-  }
-
-  if (analysis.frameworks.some(f => ['next.js', 'nuxt', 'remix'].includes(f))) {
-    tags.push('fullstack')
-  }
-
-  if (analysis.frameworks.includes('electron') || analysis.frameworks.includes('tauri')) {
-    tags.push('desktop')
-  }
-
-  return tags
-}
-
-function generateContextContent(analysis: ProjectAnalysis): string {
-  const parts: string[] = []
-
-  parts.push(`# ${analysis.name}\n`)
-
-  parts.push(`## Overview`)
-  parts.push(analysis.description || '*Add project description here*')
-  parts.push('')
-
-  parts.push(`## Tech Stack`)
-  if (analysis.languages.length > 0) {
-    parts.push(`**Languages:** ${analysis.languages.join(', ')}`)
-  }
-  if (analysis.frameworks.length > 0) {
-    parts.push(`**Frameworks:** ${analysis.frameworks.join(', ')}`)
-  }
-  if (analysis.packageManager) {
-    parts.push(`**Package Manager:** ${analysis.packageManager}`)
-  }
-  parts.push('')
-
-  parts.push(`## Architecture`)
-  parts.push(`### Project Structure`)
-  parts.push('```')
-  analysis.structure.slice(0, 15).forEach(s => parts.push(s))
-  parts.push('```')
-  parts.push('')
-
-  if (analysis.keyFiles.length > 0) {
-    parts.push(`### Key Files`)
-    analysis.keyFiles.forEach(f => parts.push(`- \`${f}\``))
-    parts.push('')
-  }
-
-  parts.push(`## Key Decisions`)
-  parts.push(`*Use \`remember_decision\` to add architectural decisions here*`)
-
-  return parts.join('\n')
-}
-
-function generateStandardsContent(analysis: ProjectAnalysis): string {
-  const parts: string[] = []
-
-  parts.push(`# Coding Standards: ${analysis.name}\n`)
-
-  parts.push(`## General Principles`)
-  analysis.conventions.forEach(c => parts.push(`- ${c}`))
-  if (analysis.conventions.length === 0) {
-    parts.push('*Add general coding principles*')
-  }
-  parts.push('')
-
-  parts.push(`## Language-Specific Standards`)
-  for (const lang of analysis.languages) {
-    parts.push(`### ${lang.charAt(0).toUpperCase() + lang.slice(1)}`)
-    parts.push(`*Add ${lang}-specific standards*`)
-    parts.push('')
-  }
-
-  if (analysis.frameworks.length > 0) {
-    parts.push(`## Framework-Specific Patterns`)
-    for (const fw of analysis.frameworks) {
-      parts.push(`### ${fw}`)
-      parts.push(`*Add ${fw}-specific patterns and conventions*`)
-      parts.push('')
-    }
-  }
-
-  parts.push(`## Common Anti-Patterns to Avoid`)
-  parts.push(`*Document patterns to avoid*`)
-
-  return parts.join('\n')
-}
-
-async function fileExists(filePath: string): Promise<boolean> {
-  try {
-    await fs.access(filePath)
-    return true
-  } catch {
-    return false
-  }
-}
+/**
+ * Init Project Handler
+ * Analyzes an existing codebase and creates project in vault
+ * Similar to `claude init` - reads files to extract project info
+ */
+
+import type { Logger } from 'pino'
+import type { ToolResponse } from '@/tools/types'
+import { getVaultService, getMemoryService, isServicesInitialized } from '@/server/services'
+import { ResponseFormatter } from '@/server/utils/response-formatter'
+import { ErrorHandler } from '@/server/utils/error-handler'
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js'
+import { PackManager, PackLoader, type PackLoadResult } from '@/packs/index'
+import fs from 'fs/promises'
+import path from 'path'
+import { fileURLToPath } from 'node:url'
+import { dirname, resolve } from 'node:path'
+
+interface InitProjectInput {
+  project_path?: string
+  project_name?: string
+  save_to_memory?: boolean
+}
+
+interface ProjectAnalysis {
+  name: string
+  description: string
+  techStack: string[]
+  frameworks: string[]
+  languages: string[]
+  packageManager: string | null
+  structure: string[]
+  keyFiles: string[]
+  scripts: Record<string, string>
+  dependencies: string[]
+  devDependencies: string[]
+  hasTests: boolean
+  hasTypeScript: boolean
+  hasLinting: boolean
+  hasFormatting: boolean
+  gitIgnorePatterns: string[]
+  conventions: string[]
+}
+
+export async function handleInitProject(
+  args: unknown,
+  logger: Logger
+): Promise<ToolResponse> {
+  try {
+    const input = args as InitProjectInput
+    const {
+      project_path = process.cwd(),
+      project_name,
+      save_to_memory = true
+    } = input
+
+    logger.info({ project_path, project_name }, 'Initializing project analysis')
+
+    if (!isServicesInitialized()) {
+      throw new McpError(
+        ErrorCode.InternalError,
+        'Services not initialized'
+      )
+    }
+
+    // Verify path exists
+    try {
+      const stats = await fs.stat(project_path)
+      if (!stats.isDirectory()) {
+        throw new McpError(
+          ErrorCode.InvalidParams,
+          `Path is not a directory: ${project_path}`
+        )
+      }
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        throw new McpError(
+          ErrorCode.InvalidParams,
+          `Directory not found: ${project_path}`
+        )
+      }
+      throw error
+    }
+
+    // Analyze the project
+    const analysis = await analyzeProject(project_path, logger)
+
+    // Use provided name or detected name
+    const finalName = project_name || analysis.name
+    const normalizedName = finalName
+      .toLowerCase()
+      .replace(/\s+/g, '-')
+      .replace(/[^a-z0-9-]/g, '')
+
+    if (!normalizedName || normalizedName.length < 2) {
+      throw new McpError(
+        ErrorCode.InvalidParams,
+        'Could not determine project name. Please provide project_name parameter.'
+      )
+    }
+
+    const vault = getVaultService()
+
+    // Check if project already exists
+    const existingProjects = await vault.listProjects()
+    const projectExists = existingProjects.includes(normalizedName)
+
+    if (!projectExists) {
+      // Create new project
+      await vault.createProject(normalizedName)
+    }
+
+    // Update project files with analysis
+    const projectPaths = vault.getProjectPaths(normalizedName)
+
+    // Update context.md
+    const contextContent = generateContextContent(analysis)
+    await vault.writer.writeMarkdownFile(
+      projectPaths.context,
+      {
+        type: 'project-context',
+        project: normalizedName,
+        status: 'active',
+        created: new Date().toISOString().split('T')[0],
+        updated: new Date().toISOString().split('T')[0],
+        tech_stack: analysis.techStack,
+        languages: analysis.languages,
+        frameworks: analysis.frameworks,
+        tags: detectTags(analysis),
+        description: analysis.description,
+        analyzed_from: project_path
+      },
+      contextContent,
+      { createBackup: projectExists }
+    )
+
+    // Update standards.md
+    const standardsContent = generateStandardsContent(analysis)
+    await vault.writer.writeMarkdownFile(
+      projectPaths.standards,
+      {
+        type: 'coding-standards',
+        project: normalizedName,
+        languages: analysis.languages,
+        frameworks: analysis.frameworks,
+        last_updated: new Date().toISOString().split('T')[0]
+      },
+      standardsContent,
+      { createBackup: projectExists }
+    )
+
+    // Save to memory for semantic search
+    if (save_to_memory) {
+      const memory = getMemoryService()
+
+      // Store project overview as a decision/context
+      const projectSummary = `
+Project: ${normalizedName}
+Description: ${analysis.description}
+Tech Stack: ${analysis.techStack.join(', ')}
+Languages: ${analysis.languages.join(', ')}
+Frameworks: ${analysis.frameworks.join(', ')}
+Key Files: ${analysis.keyFiles.join(', ')}
+Has Tests: ${analysis.hasTests}
+Has TypeScript: ${analysis.hasTypeScript}
+`.trim()
+
+      await memory.rememberDecision(
+        normalizedName,
+        'Project initialization and setup',
+        `Initialized ${normalizedName} with Claude Brain`,
+        projectSummary,
+        {
+          tags: ['project-init', 'setup', ...analysis.languages, ...analysis.frameworks]
+        }
+      )
+
+      logger.info({ normalizedName }, 'Project saved to memory')
+    }
+
+    // Phase 18: Load knowledge packs based on detected tech stack
+    let packResult: PackLoadResult | null = null
+    try {
+      const initFile = fileURLToPath(import.meta.url)
+      const initDir = dirname(initFile)
+      const PACKAGE_ROOT = resolve(initDir, '..', '..', '..', '..')
+      const dataDir = path.join(process.env.CLAUDE_BRAIN_HOME || path.join(process.env.HOME || '~', '.claude-brain'), 'data')
+
+      // Default packs config
+      const packsConfig = {
+        enabled: true,
+        packsDir: 'packs',
+        alwaysLoadCore: true,
+        alwaysLoadMeta: true,
+        communityConfidenceMultiplier: 0.8,
+        personalBoost: 1.2,
+        projectBoost: 1.15
+      }
+
+      if (packsConfig.enabled) {
+        const memory = getMemoryService()
+        const packManager = new PackManager(logger, packsConfig, PACKAGE_ROOT, dataDir)
+        const packLoader = new PackLoader(logger, memory, packManager, packsConfig)
+        packResult = await packLoader.loadPacksForProject(normalizedName, analysis.techStack)
+        logger.info({ packResult }, 'Knowledge packs loaded')
+      }
+    } catch (packError) {
+      logger.warn({ error: packError }, 'Pack loading failed (non-blocking)')
+    }
+
+    // Build response
+    const parts: string[] = []
+    parts.push(`## ${projectExists ? '🔄 Project Updated' : '✅ Project Initialized'}: ${normalizedName}\n`)
+
+    parts.push(`### Analysis Results\n`)
+    parts.push(`**Source:** \`${project_path}\`\n`)
+
+    if (analysis.description) {
+      parts.push(`**Description:** ${analysis.description}\n`)
+    }
+
+    parts.push(`\n### Tech Stack`)
+    parts.push(`- **Languages:** ${analysis.languages.join(', ') || 'Not detected'}`)
+    parts.push(`- **Frameworks:** ${analysis.frameworks.join(', ') || 'Not detected'}`)
+    parts.push(`- **Package Manager:** ${analysis.packageManager || 'Not detected'}`)
+
+    parts.push(`\n### Project Features`)
+    parts.push(`- TypeScript: ${analysis.hasTypeScript ? '✅' : '❌'}`)
+    parts.push(`- Tests: ${analysis.hasTests ? '✅' : '❌'}`)
+    parts.push(`- Linting: ${analysis.hasLinting ? '✅' : '❌'}`)
+    parts.push(`- Formatting: ${analysis.hasFormatting ? '✅' : '❌'}`)
+
+    if (analysis.keyFiles.length > 0) {
+      parts.push(`\n### Key Files Detected`)
+      analysis.keyFiles.slice(0, 10).forEach(f => parts.push(`- \`${f}\``))
+    }
+
+    if (Object.keys(analysis.scripts).length > 0) {
+      parts.push(`\n### Available Scripts`)
+      Object.entries(analysis.scripts).slice(0, 8).forEach(([name, cmd]) => {
+        parts.push(`- \`${name}\`: ${cmd.slice(0, 50)}${cmd.length > 50 ? '...' : ''}`)
+      })
+    }
+
+    if (analysis.conventions.length > 0) {
+      parts.push(`\n### Detected Conventions`)
+      analysis.conventions.forEach(c => parts.push(`- ${c}`))
+    }
+
+    parts.push(`\n### Files Created/Updated`)
+    parts.push(`- \`${normalizedName}/context.md\` - Project overview`)
+    parts.push(`- \`${normalizedName}/standards.md\` - Coding standards`)
+    parts.push(`- \`${normalizedName}/progress.md\` - Progress tracking`)
+    parts.push(`- \`${normalizedName}/decisions.md\` - Decision log`)
+
+    if (save_to_memory) {
+      parts.push(`\n### Memory`)
+      parts.push(`Project context saved to semantic memory for future recall.`)
+    }
+
+    if (packResult && packResult.packsLoaded > 0) {
+      parts.push(`\n### Knowledge Packs`)
+      parts.push(`Loaded **${packResult.packsLoaded}** pack(s) with **${packResult.entriesLoaded}** entries:`)
+      for (const detail of packResult.packDetails) {
+        parts.push(`- **${detail.name}** (${detail.entriesLoaded} entries)`)
+      }
+      if (packResult.skipped.length > 0) {
+        parts.push(`\nSkipped: ${packResult.skipped.map(s => `${s.packId} (${s.reason})`).join(', ')}`)
+      }
+    } else if (packResult && packResult.skipped.length > 0) {
+      parts.push(`\n### Knowledge Packs`)
+      parts.push(`All packs already loaded (${packResult.skipped.length} skipped).`)
+    }
+
+    parts.push(`\n### Next Steps`)
+    parts.push(`1. Use \`get_project_context("${normalizedName}")\` to view full context`)
+    parts.push(`2. Use \`remember_decision\` to save architectural decisions`)
+    parts.push(`3. Use \`recall_similar\` to search past decisions`)
+
+    logger.info({
+      project: normalizedName,
+      techStack: analysis.techStack,
+      isNew: !projectExists
+    }, 'Project initialized successfully')
+
+    return ResponseFormatter.text(parts.join('\n'))
+
+  } catch (error) {
+    ErrorHandler.logError(logger, error, { tool: 'init_project', args })
+
+    if (error instanceof McpError) {
+      throw error
+    }
+
+    // Provide detailed error message
+    if (error instanceof Error) {
+      let errorMsg = `Failed to initialize project: ${error.message}\n\n`
+
+      // Add specific troubleshooting steps based on error type
+      if (error.message.includes('EACCES') || error.message.includes('permission')) {
+        errorMsg += `**Permission Error**\n` +
+          `- Check that you have read/write permissions for the project directory\n` +
+          `- Ensure the Obsidian vault path is writable\n`
+      } else if (error.message.includes('ENOENT')) {
+        errorMsg += `**File Not Found**\n` +
+          `- Verify the project_path exists\n` +
+          `- Check that the path is absolute, not relative\n`
+      } else if (error.message.includes('parse') || error.message.includes('JSON')) {
+        errorMsg += `**Parse Error**\n` +
+          `- package.json or other config files may be malformed\n` +
+          `- Check for syntax errors in configuration files\n`
+      } else {
+        errorMsg += `**Troubleshooting:**\n` +
+          `- Ensure the directory exists and is accessible\n` +
+          `- Check file permissions in both project and vault directories\n` +
+          `- Verify config files (package.json, etc.) are valid\n`
+      }
+
+      errorMsg += `\n**Error details:** ${error.stack || error.message}`
+
+      throw new McpError(ErrorCode.InternalError, errorMsg)
+    }
+
+    throw new McpError(
+      ErrorCode.InternalError,
+      `Failed to initialize project: Unknown error occurred`
+    )
+  }
+}
+
+/**
+ * Analyze project directory
+ */
+async function analyzeProject(projectPath: string, logger: Logger): Promise<ProjectAnalysis> {
+  const analysis: ProjectAnalysis = {
+    name: path.basename(projectPath),
+    description: '',
+    techStack: [],
+    frameworks: [],
+    languages: [],
+    packageManager: null,
+    structure: [],
+    keyFiles: [],
+    scripts: {},
+    dependencies: [],
+    devDependencies: [],
+    hasTests: false,
+    hasTypeScript: false,
+    hasLinting: false,
+    hasFormatting: false,
+    gitIgnorePatterns: [],
+    conventions: []
+  }
+
+  // Read directory structure (top level + 1 deep)
+  try {
+    const entries = await fs.readdir(projectPath, { withFileTypes: true })
+
+    for (const entry of entries) {
+      if (entry.name.startsWith('.') && entry.name !== '.eslintrc.json' && entry.name !== '.prettierrc') {
+        continue
+      }
+
+      if (entry.isDirectory()) {
+        analysis.structure.push(`${entry.name}/`)
+      } else {
+        analysis.structure.push(entry.name)
+      }
+    }
+  } catch (error) {
+    logger.warn({ error }, 'Failed to read directory structure')
+  }
+
+  // Check for package.json (Node.js/JavaScript projects)
+  await analyzePackageJson(projectPath, analysis, logger)
+
+  // Check for other config files
+  await analyzeConfigFiles(projectPath, analysis, logger)
+
+  // Check for Python projects
+  await analyzePythonProject(projectPath, analysis, logger)
+
+  // Check for Go projects
+  await analyzeGoProject(projectPath, analysis, logger)
+
+  // Check for Rust projects
+  await analyzeRustProject(projectPath, analysis, logger)
+
+  // Detect test directories
+  await detectTests(projectPath, analysis, logger)
+
+  // Read README for description
+  await readReadme(projectPath, analysis, logger)
+
+  // Read .gitignore
+  await readGitignore(projectPath, analysis, logger)
+
+  // Detect conventions from structure
+  detectConventions(analysis)
+
+  // Build final tech stack
+  analysis.techStack = [...new Set([...analysis.languages, ...analysis.frameworks])]
+
+  return analysis
+}
+
+async function analyzePackageJson(projectPath: string, analysis: ProjectAnalysis, _logger: Logger) {
+  try {
+    const pkgPath = path.join(projectPath, 'package.json')
+    const content = await fs.readFile(pkgPath, 'utf-8')
+    const pkg = JSON.parse(content)
+
+    analysis.name = pkg.name || analysis.name
+    analysis.description = pkg.description || ''
+    analysis.scripts = pkg.scripts || {}
+
+    // Detect package manager
+    if (await fileExists(path.join(projectPath, 'bun.lockb'))) {
+      analysis.packageManager = 'bun'
+    } else if (await fileExists(path.join(projectPath, 'pnpm-lock.yaml'))) {
+      analysis.packageManager = 'pnpm'
+    } else if (await fileExists(path.join(projectPath, 'yarn.lock'))) {
+      analysis.packageManager = 'yarn'
+    } else if (await fileExists(path.join(projectPath, 'package-lock.json'))) {
+      analysis.packageManager = 'npm'
+    }
+
+    // Languages
+    analysis.languages.push('javascript')
+
+    // Analyze dependencies
+    const allDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    }
+
+    analysis.dependencies = Object.keys(pkg.dependencies || {})
+    analysis.devDependencies = Object.keys(pkg.devDependencies || {})
+
+    // Detect frameworks
+    if (allDeps['react']) {
+      analysis.frameworks.push('react')
+      if (allDeps['next']) analysis.frameworks.push('next.js')
+      if (allDeps['gatsby']) analysis.frameworks.push('gatsby')
+      if (allDeps['remix']) analysis.frameworks.push('remix')
+    }
+    if (allDeps['vue']) analysis.frameworks.push('vue')
+    if (allDeps['@angular/core']) analysis.frameworks.push('angular')
+    if (allDeps['svelte']) analysis.frameworks.push('svelte')
+    if (allDeps['express']) analysis.frameworks.push('express')
+    if (allDeps['fastify']) analysis.frameworks.push('fastify')
+    if (allDeps['hono']) analysis.frameworks.push('hono')
+    if (allDeps['elysia']) analysis.frameworks.push('elysia')
+    if (allDeps['nestjs'] || allDeps['@nestjs/core']) analysis.frameworks.push('nestjs')
+    if (allDeps['electron']) analysis.frameworks.push('electron')
+    if (allDeps['tauri']) analysis.frameworks.push('tauri')
+
+    // Detect TypeScript
+    if (allDeps['typescript'] || await fileExists(path.join(projectPath, 'tsconfig.json'))) {
+      analysis.hasTypeScript = true
+      analysis.languages.push('typescript')
+    }
+
+    // Detect testing
+    if (allDeps['jest'] || allDeps['vitest'] || allDeps['mocha'] || allDeps['ava']) {
+      analysis.hasTests = true
+    }
+
+    // Detect linting
+    if (allDeps['eslint'] || allDeps['biome'] || allDeps['@biomejs/biome']) {
+      analysis.hasLinting = true
+    }
+
+    // Detect formatting
+    if (allDeps['prettier'] || allDeps['biome'] || allDeps['@biomejs/biome']) {
+      analysis.hasFormatting = true
+    }
+
+    // Key files
+    analysis.keyFiles.push('package.json')
+
+  } catch (error) {
+    // Not a Node.js project
+  }
+}
+
+async function analyzeConfigFiles(projectPath: string, analysis: ProjectAnalysis, _logger: Logger) {
+  const configFiles = [
+    'tsconfig.json',
+    '.eslintrc.json',
+    '.eslintrc.js',
+    '.prettierrc',
+    'prettier.config.js',
+    'vite.config.ts',
+    'vite.config.js',
+    'webpack.config.js',
+    'rollup.config.js',
+    'tailwind.config.js',
+    'tailwind.config.ts',
+    'postcss.config.js',
+    'next.config.js',
+    'next.config.ts',
+    'nuxt.config.ts',
+    'astro.config.mjs',
+    'svelte.config.js',
+    'biome.json'
+  ]
+
+  for (const file of configFiles) {
+    if (await fileExists(path.join(projectPath, file))) {
+      analysis.keyFiles.push(file)
+
+      // Detect specific tools
+      if (file.includes('tailwind')) analysis.frameworks.push('tailwindcss')
+      if (file.includes('vite')) analysis.frameworks.push('vite')
+      if (file.includes('webpack')) analysis.frameworks.push('webpack')
+      if (file.includes('astro')) analysis.frameworks.push('astro')
+    }
+  }
+}
+
+async function analyzePythonProject(projectPath: string, analysis: ProjectAnalysis, _logger: Logger) {
+  // Check for Python files
+  if (await fileExists(path.join(projectPath, 'requirements.txt')) ||
+      await fileExists(path.join(projectPath, 'pyproject.toml')) ||
+      await fileExists(path.join(projectPath, 'setup.py'))) {
+
+    analysis.languages.push('python')
+
+    if (await fileExists(path.join(projectPath, 'requirements.txt'))) {
+      analysis.keyFiles.push('requirements.txt')
+      analysis.packageManager = 'pip'
+    }
+
+    if (await fileExists(path.join(projectPath, 'pyproject.toml'))) {
+      analysis.keyFiles.push('pyproject.toml')
+      analysis.packageManager = 'poetry'
+    }
+
+    // Check for frameworks
+    try {
+      const reqPath = path.join(projectPath, 'requirements.txt')
+      if (await fileExists(reqPath)) {
+        const content = await fs.readFile(reqPath, 'utf-8')
+        if (content.includes('django')) analysis.frameworks.push('django')
+        if (content.includes('flask')) analysis.frameworks.push('flask')
+        if (content.includes('fastapi')) analysis.frameworks.push('fastapi')
+        if (content.includes('pytest')) analysis.hasTests = true
+      }
+    } catch {}
+  }
+}
+
+async function analyzeGoProject(projectPath: string, analysis: ProjectAnalysis, _logger: Logger) {
+  if (await fileExists(path.join(projectPath, 'go.mod'))) {
+    analysis.languages.push('go')
+    analysis.keyFiles.push('go.mod')
+    analysis.packageManager = 'go modules'
+  }
+}
+
+async function analyzeRustProject(projectPath: string, analysis: ProjectAnalysis, _logger: Logger) {
+  if (await fileExists(path.join(projectPath, 'Cargo.toml'))) {
+    analysis.languages.push('rust')
+    analysis.keyFiles.push('Cargo.toml')
+    analysis.packageManager = 'cargo'
+  }
+}
+
+async function detectTests(projectPath: string, analysis: ProjectAnalysis, _logger: Logger) {
+  const testDirs = ['test', 'tests', '__tests__', 'spec', 'specs']
+
+  for (const dir of testDirs) {
+    if (await fileExists(path.join(projectPath, dir))) {
+      analysis.hasTests = true
+      analysis.keyFiles.push(`${dir}/`)
+      break
+    }
+  }
+}
+
+async function readReadme(projectPath: string, analysis: ProjectAnalysis, _logger: Logger) {
+  const readmeFiles = ['README.md', 'readme.md', 'Readme.md', 'README.txt', 'README']
+
+  for (const file of readmeFiles) {
+    try {
+      const content = await fs.readFile(path.join(projectPath, file), 'utf-8')
+      analysis.keyFiles.push(file)
+
+      // Extract first paragraph as description if not set
+      if (!analysis.description) {
+        const lines = content.split('\n')
+        for (const line of lines) {
+          const trimmed = line.trim()
+          // Skip headers and empty lines
+          if (trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('!') && trimmed.length > 20) {
+            analysis.description = trimmed.slice(0, 200)
+            break
+          }
+        }
+      }
+      break
+    } catch {}
+  }
+}
+
+async function readGitignore(projectPath: string, analysis: ProjectAnalysis, _logger: Logger) {
+  try {
+    const content = await fs.readFile(path.join(projectPath, '.gitignore'), 'utf-8')
+    analysis.gitIgnorePatterns = content
+      .split('\n')
+      .filter(line => line.trim() && !line.startsWith('#'))
+      .slice(0, 20)
+  } catch {}
+}
+
+function detectConventions(analysis: ProjectAnalysis) {
+  // Detect conventions based on structure and config
+
+  if (analysis.structure.includes('src/')) {
+    analysis.conventions.push('Source code in src/ directory')
+  }
+
+  if (analysis.structure.includes('lib/')) {
+    analysis.conventions.push('Library code in lib/ directory')
+  }
+
+  if (analysis.structure.includes('components/') || analysis.structure.some(s => s.includes('components'))) {
+    analysis.conventions.push('Component-based architecture')
+  }
+
+  if (analysis.hasTypeScript) {
+    analysis.conventions.push('TypeScript for type safety')
+  }
+
+  if (analysis.hasLinting) {
+    analysis.conventions.push('Code linting enforced')
+  }
+
+  if (analysis.hasFormatting) {
+    analysis.conventions.push('Code formatting enforced')
+  }
+
+  if (analysis.hasTests) {
+    analysis.conventions.push('Test coverage expected')
+  }
+
+  if (analysis.frameworks.includes('tailwindcss')) {
+    analysis.conventions.push('Tailwind CSS for styling')
+  }
+}
+
+function detectTags(analysis: ProjectAnalysis): string[] {
+  const tags: string[] = []
+
+  if (analysis.frameworks.some(f => ['react', 'vue', 'angular', 'svelte'].includes(f))) {
+    tags.push('frontend')
+  }
+
+  if (analysis.frameworks.some(f => ['express', 'fastify', 'nestjs', 'hono', 'elysia'].includes(f))) {
+    tags.push('backend')
+  }
+
+  if (analysis.frameworks.some(f => ['next.js', 'nuxt', 'remix'].includes(f))) {
+    tags.push('fullstack')
+  }
+
+  if (analysis.frameworks.includes('electron') || analysis.frameworks.includes('tauri')) {
+    tags.push('desktop')
+  }
+
+  return tags
+}
+
+function generateContextContent(analysis: ProjectAnalysis): string {
+  const parts: string[] = []
+
+  parts.push(`# ${analysis.name}\n`)
+
+  parts.push(`## Overview`)
+  parts.push(analysis.description || '*Add project description here*')
+  parts.push('')
+
+  parts.push(`## Tech Stack`)
+  if (analysis.languages.length > 0) {
+    parts.push(`**Languages:** ${analysis.languages.join(', ')}`)
+  }
+  if (analysis.frameworks.length > 0) {
+    parts.push(`**Frameworks:** ${analysis.frameworks.join(', ')}`)
+  }
+  if (analysis.packageManager) {
+    parts.push(`**Package Manager:** ${analysis.packageManager}`)
+  }
+  parts.push('')
+
+  parts.push(`## Architecture`)
+  parts.push(`### Project Structure`)
+  parts.push('```')
+  analysis.structure.slice(0, 15).forEach(s => parts.push(s))
+  parts.push('```')
+  parts.push('')
+
+  if (analysis.keyFiles.length > 0) {
+    parts.push(`### Key Files`)
+    analysis.keyFiles.forEach(f => parts.push(`- \`${f}\``))
+    parts.push('')
+  }
+
+  parts.push(`## Key Decisions`)
+  parts.push(`*Use \`remember_decision\` to add architectural decisions here*`)
+
+  return parts.join('\n')
+}
+
+function generateStandardsContent(analysis: ProjectAnalysis): string {
+  const parts: string[] = []
+
+  parts.push(`# Coding Standards: ${analysis.name}\n`)
+
+  parts.push(`## General Principles`)
+  analysis.conventions.forEach(c => parts.push(`- ${c}`))
+  if (analysis.conventions.length === 0) {
+    parts.push('*Add general coding principles*')
+  }
+  parts.push('')
+
+  parts.push(`## Language-Specific Standards`)
+  for (const lang of analysis.languages) {
+    parts.push(`### ${lang.charAt(0).toUpperCase() + lang.slice(1)}`)
+    parts.push(`*Add ${lang}-specific standards*`)
+    parts.push('')
+  }
+
+  if (analysis.frameworks.length > 0) {
+    parts.push(`## Framework-Specific Patterns`)
+    for (const fw of analysis.frameworks) {
+      parts.push(`### ${fw}`)
+      parts.push(`*Add ${fw}-specific patterns and conventions*`)
+      parts.push('')
+    }
+  }
+
+  parts.push(`## Common Anti-Patterns to Avoid`)
+  parts.push(`*Document patterns to avoid*`)
+
+  return parts.join('\n')
+}
+
+async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath)
+    return true
+  } catch {
+    return false
+  }
+}