prjct-cli 0.15.1 → 0.17.0

package/core/agentic/context-filter.ts

@@ -1,365 +0,0 @@
-/**
- * Intelligent Context Filtering System
- *
- * Reduces context window usage by 70-90% by loading only
- * relevant files for each specialized agent
- *
- * @version 1.0.0
- */
-
-import fs from 'fs/promises'
-import path from 'path'
-import { glob } from 'glob'
-import log from '../utils/logger'
-
-interface Agent {
-  name: string
-  [key: string]: unknown
-}
-
-interface Task {
-  [key: string]: unknown
-}
-
-interface FullContext {
-  estimatedFiles?: string[]
-  fileCount?: number
-  [key: string]: unknown
-}
-
-interface Patterns {
-  include: string[]
-  exclude: string[]
-  realExtensions?: Record<string, number>
-  projectStructure?: string[]
-  configFiles?: string[]
-  detectedTech?: Record<string, unknown>
-}
-
-interface Metrics {
-  originalFiles: number
-  filteredFiles: number
-  reductionPercent: number
-  processingTime: number
-  effectiveness: string
-}
-
-interface FilterResult {
-  files: string[]
-  patterns: {
-    preEstimated?: boolean
-    detectedTech?: Record<string, unknown>
-    projectStructure?: string[]
-    agentic?: boolean
-  }
-  metrics: Metrics
-  agent: string
-  filtered: boolean
-}
-
-class ContextFilter {
-  fileCache: Map<string, unknown>
-
-  constructor() {
-    // Cache for file analysis
-    this.fileCache = new Map()
-    // NO HARDCODED PATTERNS - Everything is agentic
-    // Claude decides what files are needed based on analysis
-  }
-
-  /**
-   * Main entry point - filters context based on agent and task
-   * IMPROVED: Supports pre-estimated files for lazy loading
-   */
-  async filterForAgent(
-    agent: Agent,
-    task: Task,
-    projectPath: string,
-    fullContext: FullContext = {}
-  ): Promise<FilterResult> {
-    const startTime = Date.now()
-
-    // If files were pre-estimated (lazy loading), use them
-    if (fullContext.estimatedFiles && fullContext.estimatedFiles.length > 0) {
-      const filteredFiles = fullContext.estimatedFiles
-
-      const metrics = this.calculateMetrics(fullContext.fileCount || filteredFiles.length, filteredFiles.length, startTime)
-
-      return {
-        files: filteredFiles,
-        patterns: { preEstimated: true },
-        metrics,
-        agent: agent.name,
-        filtered: true,
-      }
-    }
-
-    // Fallback to traditional filtering if no pre-estimation
-    // Determine what files this agent needs
-    const relevantPatterns = await this.determineRelevantPatterns(agent, task, projectPath)
-
-    // Load only relevant files
-    const filteredFiles = await this.loadRelevantFiles(projectPath, relevantPatterns)
-
-    // Calculate reduction metrics
-    const metrics = this.calculateMetrics(
-      fullContext.fileCount || 1000, // estimate if not provided
-      filteredFiles.length,
-      startTime
-    )
-
-    return {
-      files: filteredFiles,
-      patterns: {
-        detectedTech: relevantPatterns.detectedTech,
-        projectStructure: relevantPatterns.projectStructure,
-        agentic: true, // Flag indicating this was agentic, not hardcoded
-      },
-      metrics,
-      agent: agent.name,
-      filtered: true,
-    }
-  }
-
-  /**
-   * Determine which patterns to use based on agent and task
-   *
-   * 100% AGENTIC: Uses analyzer for I/O, no hardcoded tech detection.
-   * Claude decides what files matter based on actual project analysis.
-   */
-  async determineRelevantPatterns(_agent: Agent, _task: Task, projectPath: string): Promise<Patterns> {
-    const { default: analyzer } = await import('../domain/analyzer')
-    analyzer.init(projectPath)
-
-    // Get REAL file extensions from project (not assumed)
-    const realExtensions = await analyzer.getFileExtensions()
-
-    // Get REAL directory structure (not assumed)
-    const projectStructure = await analyzer.listDirectories()
-
-    // Get config files that exist (not hardcoded list)
-    const configFiles = await analyzer.listConfigFiles()
-
-    // Build patterns from ACTUAL project data
-    const patterns: Patterns = {
-      include: [],
-      exclude: ['node_modules', '.git', 'dist', 'build', 'coverage', '.next', '.nuxt', 'target', 'vendor'],
-      realExtensions, // Actual extensions found in project
-      projectStructure, // Actual directories
-      configFiles, // Actual config files
-    }
-
-    return patterns
-  }
-
-  /**
-   * Detect actual project structure (no assumptions)
-   */
-  async detectProjectStructure(projectPath: string): Promise<string[]> {
-    try {
-      const entries = await fs.readdir(projectPath, { withFileTypes: true })
-      const directories = entries.filter((e) => e.isDirectory() && !e.name.startsWith('.')).map((e) => e.name)
-      return directories
-    } catch {
-      return []
-    }
-  }
-
-  /**
-   * Detect technologies used in the project
-   *
-   * 100% AGENTIC: Uses analyzer for raw data.
-   * No categorization - Claude decides what's relevant.
-   */
-  async detectProjectTechnologies(
-    projectPath: string
-  ): Promise<{ extensions: Record<string, number>; directories: string[]; configFiles: string[] }> {
-    try {
-      const { default: analyzer } = await import('../domain/analyzer')
-      analyzer.init(projectPath)
-
-      // Return raw data for Claude to analyze
-      return {
-        extensions: await analyzer.getFileExtensions(),
-        directories: await analyzer.listDirectories(),
-        configFiles: await analyzer.listConfigFiles(),
-      }
-    } catch (error) {
-      log.error('Error detecting project data:', (error as Error).message)
-      return { extensions: {}, directories: [], configFiles: [] }
-    }
-  }
-
-  /**
-   * Load only relevant files based on patterns
-   */
-  async loadRelevantFiles(projectPath: string, patterns: Patterns): Promise<string[]> {
-    const files: string[] = []
-
-    try {
-      // Build glob patterns
-      const globPatterns = this.buildGlobPatterns(patterns)
-
-      // Execute glob searches
-      for (const pattern of globPatterns) {
-        const matches = await glob(pattern, {
-          cwd: projectPath,
-          ignore: patterns.exclude.map((ex) => `**/${ex}/**`),
-          nodir: true,
-          follow: false,
-        })
-
-        // Ensure matches is always an array (glob v10+ returns array, but be defensive)
-        if (Array.isArray(matches)) {
-          files.push(...matches)
-        } else if (matches) {
-          // Convert iterable to array if needed
-          files.push(...Array.from(matches as Iterable<string>))
-        }
-      }
-
-      // Remove duplicates and sort
-      const uniqueFiles = [...new Set(files)].sort()
-
-      // Limit to reasonable number
-      const maxFiles = 300
-      if (uniqueFiles.length > maxFiles) {
-        log.debug(`Limiting context to ${maxFiles} files`)
-        return uniqueFiles.slice(0, maxFiles)
-      }
-
-      // Expand context with related files
-      const expandedFiles = await this.expandContext(uniqueFiles, projectPath)
-
-      return expandedFiles.slice(0, maxFiles)
-    } catch (error) {
-      log.error('Error loading files:', (error as Error).message)
-      return []
-    }
-  }
-
-  /**
-   * Build glob patterns from pattern configuration
-   *
-   * 100% AGENTIC: Uses REAL extensions from project, not hardcoded mapping.
-   * No language→extension assumptions.
-   */
-  buildGlobPatterns(patterns: Patterns): string[] {
-    const globs: string[] = []
-
-    // Use REAL extensions found in project (no hardcoded mapping)
-    if (patterns.realExtensions && Object.keys(patterns.realExtensions).length > 0) {
-      // Get extensions that actually exist in this project
-      const extensions = Object.keys(patterns.realExtensions)
-        .filter((ext) => ext.startsWith('.')) // Only valid extensions
-        .slice(0, 20) // Limit to top 20 most common
-
-      if (extensions.length > 0) {
-        globs.push(`**/*{${extensions.join(',')}}`)
-      }
-    }
-
-    // Use REAL project structure (no assumptions)
-    if (patterns.projectStructure && patterns.projectStructure.length > 0) {
-      patterns.projectStructure.forEach((dir) => {
-        // Exclude universal noise directories
-        if (!patterns.exclude.includes(dir)) {
-          globs.push(`${dir}/**/*`)
-        }
-      })
-    }
-
-    // Include REAL config files that exist (not hardcoded list)
-    if (patterns.configFiles && patterns.configFiles.length > 0) {
-      patterns.configFiles.forEach((file) => {
-        globs.push(file)
-      })
-    }
-
-    // Fallback: if no patterns detected, include all source-like files
-    if (globs.length === 0) {
-      globs.push('**/*')
-    }
-
-    return globs
-  }
-
-  /**
-   * Calculate metrics for context reduction
-   */
-  calculateMetrics(originalCount: number, filteredCount: number, startTime: number): Metrics {
-    const reduction = originalCount > 0 ? Math.round(((originalCount - filteredCount) / originalCount) * 100) : 0
-
-    return {
-      originalFiles: originalCount,
-      filteredFiles: filteredCount,
-      reductionPercent: reduction,
-      processingTime: Date.now() - startTime,
-      effectiveness: reduction > 70 ? 'high' : reduction > 40 ? 'medium' : 'low',
-    }
-  }
-
-  /**
-   * Check if file exists
-   */
-  async fileExists(filePath: string): Promise<boolean> {
-    try {
-      await fs.access(filePath)
-      return true
-    } catch {
-      return false
-    }
-  }
-
-  /**
-   * Expand context with related files (tests, styles, etc.)
-   */
-  async expandContext(files: string[], _projectPath?: string): Promise<string[]> {
-    const expanded = new Set(files)
-
-    for (const file of files) {
-      const ext = path.extname(file)
-      const basename = path.basename(file, ext)
-      const dirname = path.dirname(file)
-
-      // 1. Look for test files
-      const testPatterns = [
-        path.join(dirname, `${basename}.test${ext}`),
-        path.join(dirname, `${basename}.spec${ext}`),
-        path.join(dirname, '__tests__', `${basename}.test${ext}`),
-        path.join(dirname, 'tests', `${basename}.test${ext}`),
-      ]
-
-      // 2. Look for style files (for UI components)
-      const stylePatterns = [
-        path.join(dirname, `${basename}.css`),
-        path.join(dirname, `${basename}.scss`),
-        path.join(dirname, `${basename}.module.css`),
-        path.join(dirname, `${basename}.module.scss`),
-      ]
-
-      // Check if these related files exist
-      const potentialFiles = [...testPatterns, ...stylePatterns]
-
-      for (const potential of potentialFiles) {
-        if (!expanded.has(potential) && (await this.fileExists(potential))) {
-          expanded.add(potential)
-        }
-      }
-    }
-
-    return Array.from(expanded).sort()
-  }
-
-  /**
-   * Get filter statistics
-   */
-  getStatistics(): { cachedFiles: number; agentic: boolean } {
-    return {
-      cachedFiles: this.fileCache.size,
-      agentic: true, // All filtering is now agentic, no hardcoded patterns
-    }
-  }
-}
-
-export default ContextFilter

package/core/agentic/parallel-tools.ts

@@ -1,165 +0,0 @@
-/**
- * Parallel Tools
- * Execute multiple tools in parallel for performance
- *
- * @module agentic/parallel-tools
- * @version 1.0.0
- */
-
-import fs from 'fs/promises'
-
-interface ToolCall {
-  tool: string
-  args: unknown[]
-}
-
-interface ToolResult {
-  tool: string
-  success: boolean
-  result?: unknown
-  error?: string
-  duration: number
-}
-
-interface ParallelMetrics {
-  totalCalls: number
-  parallelCalls: number
-  sequentialCalls: number
-  averageDuration: number
-  savedTime: number
-}
-
-class ParallelTools {
-  private metrics: ParallelMetrics
-
-  constructor() {
-    this.metrics = {
-      totalCalls: 0,
-      parallelCalls: 0,
-      sequentialCalls: 0,
-      averageDuration: 0,
-      savedTime: 0,
-    }
-  }
-
-  /**
-   * Execute multiple tool calls in parallel
-   */
-  async execute(toolCalls: ToolCall[]): Promise<ToolResult[]> {
-    const startTime = Date.now()
-
-    const promises = toolCalls.map(async (call) => {
-      const callStart = Date.now()
-      try {
-        const result = await this.executeOne(call.tool, call.args)
-        return {
-          tool: call.tool,
-          success: true,
-          result,
-          duration: Date.now() - callStart,
-        }
-      } catch (error) {
-        return {
-          tool: call.tool,
-          success: false,
-          error: (error as Error).message,
-          duration: Date.now() - callStart,
-        }
-      }
-    })
-
-    const results = await Promise.all(promises)
-
-    // Update metrics
-    const totalDuration = Date.now() - startTime
-    const sumIndividual = results.reduce((sum, r) => sum + r.duration, 0)
-    this.metrics.totalCalls += toolCalls.length
-    this.metrics.parallelCalls += toolCalls.length
-    this.metrics.savedTime += sumIndividual - totalDuration
-    this.metrics.averageDuration =
-      (this.metrics.averageDuration * (this.metrics.totalCalls - toolCalls.length) + totalDuration) /
-      this.metrics.totalCalls
-
-    return results
-  }
-
-  /**
-   * Execute a single tool
-   */
-  private async executeOne(tool: string, args: unknown[]): Promise<unknown> {
-    switch (tool) {
-      case 'Read':
-        return await fs.readFile(args[0] as string, 'utf-8')
-
-      case 'Write':
-        await fs.writeFile(args[0] as string, args[1] as string, 'utf-8')
-        return true
-
-      case 'GetTimestamp':
-        return new Date().toISOString()
-
-      case 'GetDate':
-        return new Date().toISOString().split('T')[0]
-
-      default:
-        throw new Error(`Unknown tool: ${tool}`)
-    }
-  }
-
-  /**
-   * Read multiple files in parallel
-   */
-  async readAll(paths: string[]): Promise<Map<string, string | null>> {
-    const results = new Map<string, string | null>()
-
-    const promises = paths.map(async (path) => {
-      try {
-        const content = await fs.readFile(path, 'utf-8')
-        return { path, content }
-      } catch {
-        return { path, content: null }
-      }
-    })
-
-    const readResults = await Promise.all(promises)
-
-    readResults.forEach(({ path, content }) => {
-      results.set(path, content)
-    })
-
-    return results
-  }
-
-  /**
-   * Check if tools can be parallelized
-   */
-  canParallelize(tools: string[]): boolean {
-    // Read operations can always be parallelized
-    const readOnlyTools = ['Read', 'Glob', 'Grep', 'GetTimestamp', 'GetDate']
-    return tools.every((tool) => readOnlyTools.includes(tool))
-  }
-
-  /**
-   * Get parallelization metrics
-   */
-  getMetrics(): ParallelMetrics {
-    return { ...this.metrics }
-  }
-
-  /**
-   * Reset metrics
-   */
-  resetMetrics(): void {
-    this.metrics = {
-      totalCalls: 0,
-      parallelCalls: 0,
-      sequentialCalls: 0,
-      averageDuration: 0,
-      savedTime: 0,
-    }
-  }
-}
-
-const parallelTools = new ParallelTools()
-export default parallelTools
-export { ParallelTools }

package/core/agentic/response-templates.ts

@@ -1,164 +0,0 @@
-/**
- * Response Templates
- * Consistent response formatting for commands
- *
- * @module agentic/response-templates
- * @version 1.0.0
- */
-
-interface ResponseData {
-  task?: string
-  duration?: string
-  feature?: string
-  filesChanged?: number
-  keyFile?: string
-  nextAction?: string
-  message?: string
-  ideas?: number
-  roadmapFeatures?: number
-  pendingTasks?: number
-  completedTasks?: number
-  error?: string
-  [key: string]: unknown
-}
-
-interface ResponseTemplate {
-  success: (data: ResponseData) => string
-  error: (data: ResponseData) => string
-}
-
-/**
- * Response templates by command
- */
-const templates: Record<string, ResponseTemplate> = {
-  done: {
-    success: (data) => `✅ ${data.task || 'Task'} (${data.duration || '?'})
-
-Files: ${data.filesChanged || 0} | Modified: ${data.keyFile || 'n/a'}
-Next: ${data.nextAction || '/p:next for queue'}`,
-
-    error: (data) => `❌ Could not complete task
-
-${data.error || 'Unknown error'}
-Try: /p:now to check current task`,
-  },
-
-  ship: {
-    success: (data) => `🚀 ${data.feature || 'Feature'} shipped!
-
-${data.message || 'Successfully deployed'}
-Next: ${data.nextAction || '/p:recap for progress'}`,
-
-    error: (data) => `❌ Ship failed
-
-${data.error || 'Unknown error'}
-Check git status and try again`,
-  },
-
-  now: {
-    success: (data) => `🎯 Now working on: ${data.task || 'Task'}
-
-${data.message || 'Focus set'}
-When done: /p:done`,
-
-    error: (data) => `❌ Could not set task
-
-${data.error || 'Unknown error'}
-Try: /p:init if project not initialized`,
-  },
-
-  feature: {
-    success: (data) => `✨ Feature added: ${data.feature || 'New feature'}
-
-${data.message || 'Added to roadmap'}
-Start: /p:now to begin first task`,
-
-    error: (data) => `❌ Could not add feature
-
-${data.error || 'Unknown error'}`,
-  },
-
-  idea: {
-    success: (data) => `💡 Idea captured!
-
-${data.message || 'Saved to ideas.md'}
-Total ideas: ${data.ideas || '?'}`,
-
-    error: (data) => `❌ Could not save idea
-
-${data.error || 'Unknown error'}`,
-  },
-
-  recap: {
-    success: (data) => `📊 Project Recap
-
-Features: ${data.roadmapFeatures || 0}
-Pending: ${data.pendingTasks || 0}
-Completed: ${data.completedTasks || 0}
-
-${data.message || ''}`,
-
-    error: (data) => `❌ Could not generate recap
-
-${data.error || 'Unknown error'}
-Try: /p:sync to refresh state`,
-  },
-
-  sync: {
-    success: (data) => `🔄 Sync complete
-
-${data.message || 'Project state updated'}
-Next: ${data.nextAction || '/p:recap for overview'}`,
-
-    error: (data) => `❌ Sync failed
-
-${data.error || 'Unknown error'}
-Try: /p:init to reinitialize`,
-  },
-
-  init: {
-    success: (data) => `🎉 Project initialized!
-
-${data.message || 'Ready to use prjct'}
-Next: /p:sync to analyze codebase`,
-
-    error: (data) => `❌ Initialization failed
-
-${data.error || 'Unknown error'}
-Check permissions and try again`,
-  },
-
-  default: {
-    success: (data) => `✅ Done
-
-${data.message || 'Operation completed'}`,
-
-    error: (data) => `❌ Failed
-
-${data.error || 'Unknown error'}`,
-  },
-}
-
-/**
- * Format response for a command
- */
-function format(commandName: string, data: ResponseData): string {
-  const template = templates[commandName] || templates.default
-  const success = data.error ? false : true
-
-  if (success) {
-    return template.success(data)
-  } else {
-    return template.error(data)
-  }
-}
-
-/**
- * Get template for command
- */
-function getTemplate(commandName: string): ResponseTemplate {
-  return templates[commandName] || templates.default
-}
-
-export { format, getTemplate, templates }
-export default { format, getTemplate, templates }