prjct-cli 0.11.5 → 0.12.0

package/core/agentic/{context-builder.js → context-builder.ts}

@@ -6,15 +6,49 @@
  * @version 0.1
  */
 
-const fs = require('fs').promises
-const pathManager = require('../infrastructure/path-manager')
-const configManager = require('../infrastructure/config-manager')
+import fs from 'fs/promises'
+import pathManager from '../infrastructure/path-manager'
+import configManager from '../infrastructure/config-manager'
+
+interface Paths {
+  now: string
+  next: string
+  context: string
+  shipped: string
+  metrics: string
+  ideas: string
+  roadmap: string
+  specs: string
+  memory: string
+  patterns: string
+  analysis: string
+  codePatterns: string
+}
+
+interface Context {
+  projectId: string | null
+  projectPath: string
+  globalPath: string
+  paths: Paths
+  params: Record<string, unknown>
+  timestamp: string
+  date: string
+}
+
+interface State {
+  [key: string]: string | null
+}
 
 /**
  * Builds and caches project context for Claude decisions.
  * Features parallel reads, selective loading, and anti-hallucination mtime checks.
  */
 class ContextBuilder {
+  private _cache: Map<string, string | null>
+  private _cacheTimeout: number
+  private _lastCacheTime: number | null
+  private _mtimes: Map<string, number>
+
   constructor() {
     // Session cache - cleared between commands or after timeout
     this._cache = new Map()
@@ -27,11 +61,9 @@ class ContextBuilder {
 
   /**
    * Clear cache if stale or force clear
-   * @param {boolean} force - Force clear regardless of timeout
    */
-  _clearCacheIfStale(force = false) {
-    if (force || !this._lastCacheTime ||
-        Date.now() - this._lastCacheTime > this._cacheTimeout) {
+  private _clearCacheIfStale(force: boolean = false): void {
+    if (force || !this._lastCacheTime || Date.now() - this._lastCacheTime > this._cacheTimeout) {
       this._cache.clear()
       this._lastCacheTime = Date.now()
     }
@@ -39,13 +71,10 @@ class ContextBuilder {
 
   /**
    * Build full project context for Claude
-   * @param {string} projectPath - Local project path
-   * @param {Object} commandParams - Command-specific parameters
-   * @returns {Promise<Object>} Context object
    */
-  async build(projectPath, commandParams = {}) {
+  async build(projectPath: string, commandParams: Record<string, unknown> = {}): Promise<Context> {
     const projectId = await configManager.getProjectId(projectPath)
-    const globalPath = pathManager.getGlobalProjectPath(projectId)
+    const globalPath = pathManager.getGlobalProjectPath(projectId!)
 
     return {
       // Project identification
@@ -55,18 +84,18 @@ class ContextBuilder {
 
       // File paths
       paths: {
-        now: pathManager.getFilePath(projectId, 'core', 'now.md'),
-        next: pathManager.getFilePath(projectId, 'core', 'next.md'),
-        context: pathManager.getFilePath(projectId, 'core', 'context.md'),
-        shipped: pathManager.getFilePath(projectId, 'progress', 'shipped.md'),
-        metrics: pathManager.getFilePath(projectId, 'progress', 'metrics.md'),
-        ideas: pathManager.getFilePath(projectId, 'planning', 'ideas.md'),
-        roadmap: pathManager.getFilePath(projectId, 'planning', 'roadmap.md'),
-        specs: pathManager.getFilePath(projectId, 'planning', 'specs'),
-        memory: pathManager.getFilePath(projectId, 'memory', 'context.jsonl'),
-        patterns: pathManager.getFilePath(projectId, 'memory', 'patterns.json'),
-        analysis: pathManager.getFilePath(projectId, 'analysis', 'repo-summary.md'),
-        codePatterns: pathManager.getFilePath(projectId, 'analysis', 'patterns.md'),
+        now: pathManager.getFilePath(projectId!, 'core', 'now.md'),
+        next: pathManager.getFilePath(projectId!, 'core', 'next.md'),
+        context: pathManager.getFilePath(projectId!, 'core', 'context.md'),
+        shipped: pathManager.getFilePath(projectId!, 'progress', 'shipped.md'),
+        metrics: pathManager.getFilePath(projectId!, 'progress', 'metrics.md'),
+        ideas: pathManager.getFilePath(projectId!, 'planning', 'ideas.md'),
+        roadmap: pathManager.getFilePath(projectId!, 'planning', 'roadmap.md'),
+        specs: pathManager.getFilePath(projectId!, 'planning', 'specs'),
+        memory: pathManager.getFilePath(projectId!, 'memory', 'context.jsonl'),
+        patterns: pathManager.getFilePath(projectId!, 'memory', 'patterns.json'),
+        analysis: pathManager.getFilePath(projectId!, 'analysis', 'repo-summary.md'),
+        codePatterns: pathManager.getFilePath(projectId!, 'analysis', 'patterns.md'),
       },
 
       // Command parameters
@@ -82,21 +111,15 @@ class ContextBuilder {
   /**
    * Load current project state - PARALLEL VERSION
    * Uses Promise.all() for 40-60% faster file I/O
-   *
-   * @param {Object} context - Context from build()
-   * @param {string[]} onlyKeys - Optional: only load specific keys (selective loading)
-   * @returns {Promise<Object>} Current state
    */
-  async loadState(context, onlyKeys = null) {
+  async loadState(context: Context, onlyKeys: string[] | null = null): Promise<State> {
     this._clearCacheIfStale()
 
-    const state = {}
+    const state: State = {}
     const entries = Object.entries(context.paths)
 
     // Filter to only requested keys if specified
-    const filteredEntries = onlyKeys
-      ? entries.filter(([key]) => onlyKeys.includes(key))
-      : entries
+    const filteredEntries = onlyKeys ? entries.filter(([key]) => onlyKeys.includes(key)) : entries
 
     // ANTI-HALLUCINATION: Verify mtime before trusting cache
     // Files can change between commands - stale cache causes hallucinations
@@ -119,10 +142,10 @@ class ContextBuilder {
     }
 
     // Separate cached vs uncached files
-    const uncachedEntries = []
+    const uncachedEntries: [string, string][] = []
     for (const [key, filePath] of filteredEntries) {
       if (this._cache.has(filePath)) {
-        state[key] = this._cache.get(filePath)
+        state[key] = this._cache.get(filePath)!
       } else {
         uncachedEntries.push([key, filePath])
       }
@@ -132,10 +155,7 @@ class ContextBuilder {
     if (uncachedEntries.length > 0) {
       const readPromises = uncachedEntries.map(async ([key, filePath]) => {
         try {
-          const [content, stat] = await Promise.all([
-            fs.readFile(filePath, 'utf-8'),
-            fs.stat(filePath)
-          ])
+          const [content, stat] = await Promise.all([fs.readFile(filePath, 'utf-8'), fs.stat(filePath)])
           return { key, filePath, content, mtime: stat.mtimeMs }
         } catch {
           return { key, filePath, content: null, mtime: null }
@@ -160,46 +180,42 @@ class ContextBuilder {
   /**
    * Load state for specific command - optimized selective loading
    * Each command only loads what it needs
-   *
-   * @param {Object} context - Context from build()
-   * @param {string} commandName - Command name for selective loading
-   * @returns {Promise<Object>} Current state (filtered)
    */
-  async loadStateForCommand(context, commandName) {
+  async loadStateForCommand(context: Context, commandName: string): Promise<State> {
     // Command-specific file requirements
     // Minimizes context window usage
     // CRITICAL: Include 'codePatterns' for ALL code-modifying commands
-    const commandFileMap = {
+    const commandFileMap: Record<string, string[]> = {
       // Core workflow
-      'now': ['now', 'next', 'analysis', 'codePatterns'],
-      'done': ['now', 'next', 'metrics', 'analysis'],
-      'next': ['next', 'analysis'],
+      now: ['now', 'next', 'analysis', 'codePatterns'],
+      done: ['now', 'next', 'metrics', 'analysis'],
+      next: ['next', 'analysis'],
 
       // Progress
-      'ship': ['now', 'shipped', 'metrics', 'analysis'],
-      'recap': ['shipped', 'metrics', 'now', 'analysis'],
-      'progress': ['shipped', 'metrics', 'analysis'],
+      ship: ['now', 'shipped', 'metrics', 'analysis'],
+      recap: ['shipped', 'metrics', 'now', 'analysis'],
+      progress: ['shipped', 'metrics', 'analysis'],
 
       // Planning
-      'idea': ['ideas', 'next', 'analysis'],
-      'feature': ['roadmap', 'next', 'ideas', 'analysis', 'codePatterns'],
-      'roadmap': ['roadmap', 'analysis'],
-      'spec': ['roadmap', 'next', 'specs', 'analysis', 'codePatterns'],
+      idea: ['ideas', 'next', 'analysis'],
+      feature: ['roadmap', 'next', 'ideas', 'analysis', 'codePatterns'],
+      roadmap: ['roadmap', 'analysis'],
+      spec: ['roadmap', 'next', 'specs', 'analysis', 'codePatterns'],
 
       // Analysis
-      'analyze': ['analysis', 'context', 'codePatterns'],
-      'sync': ['analysis', 'context', 'now', 'codePatterns'],
+      analyze: ['analysis', 'context', 'codePatterns'],
+      sync: ['analysis', 'context', 'now', 'codePatterns'],
 
       // Code modification commands - ALWAYS need codePatterns
-      'work': ['now', 'next', 'analysis', 'context', 'codePatterns'],
-      'build': ['now', 'next', 'analysis', 'context', 'codePatterns'],
-      'design': ['analysis', 'context', 'codePatterns'],
-      'cleanup': ['analysis', 'context', 'codePatterns'],
-      'fix': ['analysis', 'context', 'codePatterns'],
-      'test': ['analysis', 'context', 'codePatterns'],
+      work: ['now', 'next', 'analysis', 'context', 'codePatterns'],
+      build: ['now', 'next', 'analysis', 'context', 'codePatterns'],
+      design: ['analysis', 'context', 'codePatterns'],
+      cleanup: ['analysis', 'context', 'codePatterns'],
+      fix: ['analysis', 'context', 'codePatterns'],
+      test: ['analysis', 'context', 'codePatterns'],
 
       // All files (fallback) - include codePatterns for any code work
-      'default': ['analysis', 'codePatterns']
+      default: ['analysis', 'codePatterns'],
     }
 
     const requiredFiles = commandFileMap[commandName] || commandFileMap.default
@@ -209,20 +225,17 @@ class ContextBuilder {
   /**
    * Batch read multiple files in parallel
    * Utility for custom file sets
-   *
-   * @param {string[]} filePaths - Array of file paths
-   * @returns {Promise<Map<string, string|null>>} Map of path -> content
    */
-  async batchRead(filePaths) {
+  async batchRead(filePaths: string[]): Promise<Map<string, string | null>> {
     this._clearCacheIfStale()
 
-    const results = new Map()
-    const uncachedPaths = []
+    const results = new Map<string, string | null>()
+    const uncachedPaths: string[] = []
 
     // Check cache first
     for (const filePath of filePaths) {
       if (this._cache.has(filePath)) {
-        results.set(filePath, this._cache.get(filePath))
+        results.set(filePath, this._cache.get(filePath)!)
       } else {
         uncachedPaths.push(filePath)
       }
@@ -252,25 +265,22 @@ class ContextBuilder {
 
   /**
    * Invalidate cache for specific file (after write)
-   * @param {string} filePath - File that was written
    */
-  invalidateCache(filePath) {
+  invalidateCache(filePath: string): void {
     this._cache.delete(filePath)
   }
 
   /**
    * Force clear entire cache
    */
-  clearCache() {
+  clearCache(): void {
     this._clearCacheIfStale(true)
   }
 
   /**
    * Check file existence
-   * @param {string} filePath - File path
-   * @returns {Promise<boolean>}
    */
-  async fileExists(filePath) {
+  async fileExists(filePath: string): Promise<boolean> {
     try {
       await fs.access(filePath)
       return true
@@ -281,15 +291,16 @@ class ContextBuilder {
 
   /**
    * Get cache stats (for debugging/metrics)
-   * @returns {Object} Cache statistics
    */
-  getCacheStats() {
+  getCacheStats(): { size: number; lastRefresh: number | null; timeout: number } {
     return {
       size: this._cache.size,
       lastRefresh: this._lastCacheTime,
-      timeout: this._cacheTimeout
+      timeout: this._cacheTimeout,
     }
   }
 }
 
-module.exports = new ContextBuilder()
+const contextBuilder = new ContextBuilder()
+export default contextBuilder
+export { ContextBuilder }

package/core/agentic/context-filter.ts

@@ -0,0 +1,365 @@
+/**
+ * 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