prjct-cli 1.22.0 → 1.23.0

package/core/domain/analyzer.ts

@@ -1,387 +0,0 @@
-/**
- * CodebaseAnalyzer - Provides helpers for project analysis
- *
- * 100% AGENTIC - No predetermined patterns or regex detection.
- * Claude reads the codebase and decides what's relevant.
- *
- * This class only provides I/O helpers. All analysis logic
- * is driven by Claude reading templates/analysis/analyze.md
- *
- * @version 0.6.0 - Fully agentic refactor
- */
-
-import { exec as execCallback } from 'node:child_process'
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { promisify } from 'node:util'
-import { isNotFoundError } from '../types/fs'
-
-const exec = promisify(execCallback)
-
-interface PackageJson {
-  name?: string
-  version?: string
-  dependencies?: Record<string, string>
-  devDependencies?: Record<string, string>
-  scripts?: Record<string, string>
-  [key: string]: unknown
-}
-
-interface ComposerJson {
-  name?: string
-  require?: Record<string, string>
-  'require-dev'?: Record<string, string>
-  [key: string]: unknown
-}
-
-interface GitStats {
-  totalCommits: number
-  contributors: number
-  age: string
-}
-
-interface FileExtensions {
-  [extension: string]: number
-}
-
-class CodebaseAnalyzer {
-  projectPath: string | null = null
-
-  /**
-   * Initialize analyzer for a project
-   */
-  init(projectPath: string = process.cwd()): void {
-    this.projectPath = projectPath
-  }
-
-  /**
-   * Read package.json if it exists
-   */
-  async readPackageJson(): Promise<PackageJson | null> {
-    try {
-      const packagePath = path.join(this.projectPath!, 'package.json')
-      const content = await fs.readFile(packagePath, 'utf-8')
-      return JSON.parse(content)
-    } catch (error) {
-      if (isNotFoundError(error) || error instanceof SyntaxError) {
-        return null
-      }
-      throw error
-    }
-  }
-
-  /**
-   * Read Cargo.toml if it exists
-   */
-  async readCargoToml(): Promise<string | null> {
-    try {
-      const cargoPath = path.join(this.projectPath!, 'Cargo.toml')
-      return await fs.readFile(cargoPath, 'utf-8')
-    } catch (error) {
-      if (isNotFoundError(error)) {
-        return null
-      }
-      throw error
-    }
-  }
-
-  /**
-   * Read requirements.txt if it exists
-   */
-  async readRequirements(): Promise<string | null> {
-    try {
-      const reqPath = path.join(this.projectPath!, 'requirements.txt')
-      return await fs.readFile(reqPath, 'utf-8')
-    } catch (error) {
-      if (isNotFoundError(error)) {
-        return null
-      }
-      throw error
-    }
-  }
-
-  /**
-   * Read go.mod if it exists
-   */
-  async readGoMod(): Promise<string | null> {
-    try {
-      const goModPath = path.join(this.projectPath!, 'go.mod')
-      return await fs.readFile(goModPath, 'utf-8')
-    } catch (error) {
-      if (isNotFoundError(error)) {
-        return null
-      }
-      throw error
-    }
-  }
-
-  /**
-   * Read Gemfile if it exists (Ruby)
-   */
-  async readGemfile(): Promise<string | null> {
-    try {
-      const gemfilePath = path.join(this.projectPath!, 'Gemfile')
-      return await fs.readFile(gemfilePath, 'utf-8')
-    } catch (error) {
-      if (isNotFoundError(error)) {
-        return null
-      }
-      throw error
-    }
-  }
-
-  /**
-   * Read mix.exs if it exists (Elixir)
-   */
-  async readMixExs(): Promise<string | null> {
-    try {
-      const mixPath = path.join(this.projectPath!, 'mix.exs')
-      return await fs.readFile(mixPath, 'utf-8')
-    } catch (error) {
-      if (isNotFoundError(error)) {
-        return null
-      }
-      throw error
-    }
-  }
-
-  /**
-   * Read pom.xml if it exists (Java/Maven)
-   */
-  async readPomXml(): Promise<string | null> {
-    try {
-      const pomPath = path.join(this.projectPath!, 'pom.xml')
-      return await fs.readFile(pomPath, 'utf-8')
-    } catch (error) {
-      if (isNotFoundError(error)) {
-        return null
-      }
-      throw error
-    }
-  }
-
-  /**
-   * Read composer.json if it exists (PHP)
-   */
-  async readComposerJson(): Promise<ComposerJson | null> {
-    try {
-      const composerPath = path.join(this.projectPath!, 'composer.json')
-      const content = await fs.readFile(composerPath, 'utf-8')
-      return JSON.parse(content)
-    } catch (error) {
-      if (isNotFoundError(error) || error instanceof SyntaxError) {
-        return null
-      }
-      throw error
-    }
-  }
-
-  /**
-   * Read pyproject.toml if it exists (Python)
-   */
-  async readPyprojectToml(): Promise<string | null> {
-    try {
-      const pyprojectPath = path.join(this.projectPath!, 'pyproject.toml')
-      return await fs.readFile(pyprojectPath, 'utf-8')
-    } catch (error) {
-      if (isNotFoundError(error)) {
-        return null
-      }
-      throw error
-    }
-  }
-
-  /**
-   * Get all file extensions in project with counts
-   * I/O PURO - Solo cuenta, no interpreta
-   */
-  async getFileExtensions(): Promise<FileExtensions> {
-    try {
-      const { stdout } = await exec(
-        'find . -type f ! -path "*/node_modules/*" ! -path "*/.git/*" ! -path "*/dist/*" ! -path "*/.next/*" | sed "s/.*\\./\\./" | sort | uniq -c | sort -rn',
-        { cwd: this.projectPath! }
-      )
-      const extensions: FileExtensions = {}
-      stdout
-        .trim()
-        .split('\n')
-        .filter(Boolean)
-        .forEach((line) => {
-          const match = line.trim().match(/^\s*(\d+)\s+(\.\w+)$/)
-          if (match) {
-            extensions[match[2]] = parseInt(match[1], 10)
-          }
-        })
-      return extensions
-    } catch (_error) {
-      // exec errors (find command not available, etc.) - return empty
-      return {}
-    }
-  }
-
-  /**
-   * List all config files in project root
-   * I/O PURO - Solo lista, no categoriza
-   */
-  async listConfigFiles(): Promise<string[]> {
-    try {
-      const entries = await fs.readdir(this.projectPath!)
-      const configPatterns = [
-        /^package\.json$/,
-        /^Cargo\.toml$/,
-        /^go\.mod$/,
-        /^requirements\.txt$/,
-        /^Gemfile$/,
-        /^mix\.exs$/,
-        /^pom\.xml$/,
-        /^composer\.json$/,
-        /^pyproject\.toml$/,
-        /^tsconfig.*\.json$/,
-        /^\..*rc(\.json|\.js|\.cjs)?$/,
-        /^Dockerfile$/,
-        /^docker-compose.*\.ya?ml$/,
-        /^\.env.*$/,
-      ]
-      return entries.filter((entry) => configPatterns.some((pattern) => pattern.test(entry)))
-    } catch (error) {
-      if (isNotFoundError(error)) {
-        return []
-      }
-      throw error
-    }
-  }
-
-  /**
-   * List all directories in project root
-   */
-  async listDirectories(): Promise<string[]> {
-    try {
-      const entries = await fs.readdir(this.projectPath!, { withFileTypes: true })
-      return entries
-        .filter((entry) => entry.isDirectory())
-        .map((entry) => entry.name)
-        .filter((name) => !name.startsWith('.') && name !== 'node_modules')
-    } catch (error) {
-      if (isNotFoundError(error)) {
-        return []
-      }
-      throw error
-    }
-  }
-
-  /**
-   * Get git log (last N commits)
-   */
-  async getGitLog(limit: number = 50): Promise<string> {
-    try {
-      const { stdout } = await exec(`git log -n ${limit} --pretty=format:"%h|%an|%ar|%s"`, {
-        cwd: this.projectPath!,
-      })
-      return stdout
-    } catch (_error) {
-      // Git errors (not a repo, git not installed) - return empty
-      return ''
-    }
-  }
-
-  /**
-   * Get git statistics
-   */
-  async getGitStats(): Promise<GitStats> {
-    try {
-      const { stdout: totalCommits } = await exec('git rev-list --count HEAD', {
-        cwd: this.projectPath!,
-      })
-
-      const { stdout: contributors } = await exec('git log --format="%an" | sort -u | wc -l', {
-        cwd: this.projectPath!,
-      })
-
-      const { stdout: firstCommit } = await exec(
-        'git log --reverse --pretty=format:"%ar" | head -1',
-        {
-          cwd: this.projectPath!,
-        }
-      )
-
-      return {
-        totalCommits: parseInt(totalCommits.trim(), 10) || 0,
-        contributors: parseInt(contributors.trim(), 10) || 0,
-        age: firstCommit.trim() || 'unknown',
-      }
-    } catch (_error) {
-      // Git errors (not a repo, git not installed) - return defaults
-      return {
-        totalCommits: 0,
-        contributors: 0,
-        age: 'unknown',
-      }
-    }
-  }
-
-  /**
-   * Count total files (excluding common ignore patterns)
-   */
-  async countFiles(): Promise<number> {
-    try {
-      const { stdout } = await exec(
-        'find . -type f ! -path "*/node_modules/*" ! -path "*/.git/*" ! -path "*/dist/*" | wc -l',
-        { cwd: this.projectPath! }
-      )
-      return parseInt(stdout.trim(), 10) || 0
-    } catch (_error) {
-      // exec errors (find command not available, etc.) - return 0
-      return 0
-    }
-  }
-
-  /**
-   * Check if file exists
-   */
-  async fileExists(filename: string): Promise<boolean> {
-    try {
-      await fs.access(path.join(this.projectPath!, filename))
-      return true
-    } catch (error) {
-      if (isNotFoundError(error)) {
-        return false
-      }
-      throw error
-    }
-  }
-
-  /**
-   * Read any file in the project
-   */
-  async readFile(relativePath: string): Promise<string | null> {
-    try {
-      const fullPath = path.join(this.projectPath!, relativePath)
-      return await fs.readFile(fullPath, 'utf-8')
-    } catch (error) {
-      if (isNotFoundError(error)) {
-        return null
-      }
-      throw error
-    }
-  }
-
-  /**
-   * Find files matching a pattern
-   */
-  async findFiles(pattern: string): Promise<string[]> {
-    try {
-      const { stdout } = await exec(
-        `find . -type f -name "${pattern}" ! -path "*/node_modules/*" ! -path "*/.git/*"`,
-        { cwd: this.projectPath! }
-      )
-      return stdout.trim().split('\n').filter(Boolean)
-    } catch (_error) {
-      // exec errors (find command not available, etc.) - return empty
-      return []
-    }
-  }
-}
-
-const analyzer = new CodebaseAnalyzer()
-export default analyzer
-export { CodebaseAnalyzer }

package/core/domain/architecture-generator.ts

@@ -1,108 +0,0 @@
-/**
- * Architecture Generator - Coordinates architecture generation
- * AGENTIC: Claude generates content via templates/architect/*.md
- * This file only provides structure - real content from Claude
- */
-
-import fs from 'node:fs/promises'
-import path from 'node:path'
-
-interface ArchitectureContext {
-  [key: string]: unknown
-}
-
-interface Architecture {
-  id: string
-  idea: string
-  createdAt: string
-  phases: Record<string, unknown>
-  _agenticNote: string
-}
-
-class ArchitectureGenerator {
-  defaultPhases: string[]
-
-  constructor() {
-    // AGENTIC: Phases determined by Claude via templates/architect/phases.md
-    this.defaultPhases = [
-      'discovery',
-      'user-flows',
-      'domain-modeling',
-      'api-design',
-      'architecture',
-      'data-design',
-      'tech-stack',
-      'roadmap',
-    ]
-  }
-
-  /**
-   * Generate architecture skeleton
-   * AGENTIC: Claude fills in content using templates
-   */
-  async generateArchitecture(
-    idea: string,
-    _context: ArchitectureContext = {}
-  ): Promise<Architecture> {
-    // Return skeleton - Claude generates actual content via templates
-    return {
-      id: `arch-${Date.now()}`,
-      idea,
-      createdAt: new Date().toISOString(),
-      phases: {},
-      // AGENTIC: Claude populates phases using templates/architect/*.md
-      _agenticNote:
-        'Use templates/architect/phases.md to determine needed phases, then templates/architect/discovery.md etc for content',
-    }
-  }
-
-  /**
-   * Get template path for a phase
-   */
-  getPhaseTemplate(phase: string): string | null {
-    const templateMap: Record<string, string> = {
-      discovery: 'templates/architect/discovery.md',
-      'user-flows': 'templates/design/flow.md',
-      'domain-modeling': 'templates/design/database.md',
-      'api-design': 'templates/design/api.md',
-      architecture: 'templates/design/architecture.md',
-      'data-design': 'templates/design/database.md',
-      'tech-stack': 'templates/design/architecture.md',
-      roadmap: 'templates/commands/feature.md',
-    }
-    return templateMap[phase] || null
-  }
-
-  /**
-   * Save architecture to files
-   * AGENTIC: Format determined by Claude based on content
-   */
-  async saveArchitecture(architecture: Architecture, projectPath: string): Promise<string> {
-    const archPath = path.join(projectPath, 'planning', 'architectures', architecture.id)
-    await fs.mkdir(archPath, { recursive: true })
-
-    // Save summary
-    await fs.writeFile(path.join(archPath, 'summary.json'), JSON.stringify(architecture, null, 2))
-
-    // AGENTIC: Claude generates and saves phase files directly
-    return archPath
-  }
-
-  /**
-   * SQL type mapping utility
-   */
-  sqlType(type: string): string {
-    const typeMap: Record<string, string> = {
-      uuid: 'UUID',
-      string: 'VARCHAR(255)',
-      text: 'TEXT',
-      int: 'INTEGER',
-      timestamp: 'TIMESTAMP',
-      boolean: 'BOOLEAN',
-      json: 'JSONB',
-    }
-    return typeMap[type] || 'TEXT'
-  }
-}
-
-export default ArchitectureGenerator