prjct-cli 0.11.4 → 0.12.0

package/core/agentic/response-templates.ts

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

package/core/agentic/semantic-compression.ts

@@ -0,0 +1,273 @@
+/**
+ * Semantic Compression
+ * Compresses context while preserving meaning
+ *
+ * @module agentic/semantic-compression
+ * @version 1.0.0
+ */
+
+interface CompressionResult {
+  summary: string
+  originalLength: number
+  compressedLength: number
+  ratio: number
+  key: string
+}
+
+interface CompressionMetrics {
+  totalOriginal: number
+  totalCompressed: number
+  overallRatio: number
+  compressions: number
+}
+
+class SemanticCompression {
+  private metrics: CompressionMetrics
+
+  constructor() {
+    this.metrics = {
+      totalOriginal: 0,
+      totalCompressed: 0,
+      overallRatio: 1,
+      compressions: 0,
+    }
+  }
+
+  /**
+   * Compress content while preserving semantic meaning
+   */
+  compress(content: string, key: string): CompressionResult {
+    if (!content || !content.trim()) {
+      return {
+        summary: 'Empty',
+        originalLength: 0,
+        compressedLength: 0,
+        ratio: 1,
+        key,
+      }
+    }
+
+    const originalLength = content.length
+    let summary: string
+
+    // Apply key-specific compression strategies
+    switch (key) {
+      case 'now':
+        summary = this.compressNow(content)
+        break
+      case 'next':
+        summary = this.compressNext(content)
+        break
+      case 'shipped':
+        summary = this.compressShipped(content)
+        break
+      case 'analysis':
+        summary = this.compressAnalysis(content)
+        break
+      case 'roadmap':
+        summary = this.compressRoadmap(content)
+        break
+      case 'codePatterns':
+        summary = this.compressCodePatterns(content)
+        break
+      default:
+        summary = this.compressGeneric(content)
+    }
+
+    const compressedLength = summary.length
+    const ratio = originalLength > 0 ? compressedLength / originalLength : 1
+
+    // Update metrics
+    this.metrics.totalOriginal += originalLength
+    this.metrics.totalCompressed += compressedLength
+    this.metrics.compressions++
+    this.metrics.overallRatio =
+      this.metrics.totalOriginal > 0 ? this.metrics.totalCompressed / this.metrics.totalOriginal : 1
+
+    return {
+      summary,
+      originalLength,
+      compressedLength,
+      ratio,
+      key,
+    }
+  }
+
+  /**
+   * Compress now.md content
+   */
+  private compressNow(content: string): string {
+    // Extract task description
+    const taskMatch = content.match(/task:\s*["']?([^"'\n]+)["']?/i) || content.match(/#+\s*(.+)/m)
+    const task = taskMatch ? taskMatch[1].trim() : 'Unknown task'
+
+    // Extract started time
+    const startedMatch = content.match(/started:\s*(.+)/i)
+    const started = startedMatch ? startedMatch[1].trim() : ''
+
+    // Extract agent if present
+    const agentMatch = content.match(/agent:\s*(.+)/i)
+    const agent = agentMatch ? agentMatch[1].trim() : ''
+
+    let summary = `Task: ${task}`
+    if (started) summary += ` | Started: ${started}`
+    if (agent) summary += ` | Agent: ${agent}`
+
+    return summary
+  }
+
+  /**
+   * Compress next.md content
+   */
+  private compressNext(content: string): string {
+    // Count tasks
+    const pending = (content.match(/- \[ \]/g) || []).length
+    const completed = (content.match(/- \[x\]/gi) || []).length
+    const total = pending + completed
+
+    // Get first few pending tasks
+    const taskLines = content.match(/- \[ \] .+/g) || []
+    const topTasks = taskLines.slice(0, 3).map((t) => t.replace('- [ ] ', '').trim())
+
+    let summary = `Queue: ${pending} pending, ${completed} done (${total} total)`
+    if (topTasks.length > 0) {
+      summary += ` | Next: ${topTasks.join(', ')}`
+    }
+
+    return summary
+  }
+
+  /**
+   * Compress shipped.md content
+   */
+  private compressShipped(content: string): string {
+    // Count shipped items
+    const shipped = (content.match(/^##\s+/gm) || []).length
+    const lines = content.split('\n')
+
+    // Get most recent ship
+    let recentShip = ''
+    for (const line of lines) {
+      if (line.startsWith('## ')) {
+        recentShip = line.replace('## ', '').trim()
+        break
+      }
+    }
+
+    let summary = `Shipped: ${shipped} items`
+    if (recentShip) summary += ` | Recent: ${recentShip.substring(0, 50)}`
+
+    return summary
+  }
+
+  /**
+   * Compress analysis content
+   */
+  private compressAnalysis(content: string): string {
+    // Extract stack
+    const stackMatch =
+      content.match(/stack[:\s]+([^\n]+)/i) ||
+      content.match(/technology[:\s]+([^\n]+)/i) ||
+      content.match(/framework[:\s]+([^\n]+)/i)
+    const stack = stackMatch ? stackMatch[1].trim() : 'Unknown'
+
+    // Extract file count if present
+    const filesMatch = content.match(/(\d+)\s*files/i)
+    const files = filesMatch ? filesMatch[1] : ''
+
+    // Extract language
+    const langMatch = content.match(/language[:\s]+([^\n]+)/i) || content.match(/primary[:\s]+([^\n]+)/i)
+    const language = langMatch ? langMatch[1].trim() : ''
+
+    let summary = `Stack: ${stack}`
+    if (language) summary += ` | Language: ${language}`
+    if (files) summary += ` | Files: ${files}`
+
+    return summary
+  }
+
+  /**
+   * Compress roadmap content
+   */
+  private compressRoadmap(content: string): string {
+    // Count features
+    const features = (content.match(/^##\s+/gm) || []).length
+
+    // Get feature names
+    const featureNames: string[] = []
+    const matches = content.match(/^##\s+(.+)/gm) || []
+    matches.slice(0, 3).forEach((m) => {
+      featureNames.push(m.replace(/^##\s+/, '').trim())
+    })
+
+    let summary = `Roadmap: ${features} features`
+    if (featureNames.length > 0) {
+      summary += ` | Top: ${featureNames.join(', ')}`
+    }
+
+    return summary
+  }
+
+  /**
+   * Compress code patterns content
+   */
+  private compressCodePatterns(content: string): string {
+    // Extract conventions section
+    const conventionsMatch = content.match(/## Conventions[\s\S]*?(?=##|$)/i)
+    let conventions = ''
+    if (conventionsMatch) {
+      const lines = conventionsMatch[0]
+        .split('\n')
+        .filter((l) => l.includes(':') || l.startsWith('-'))
+        .slice(0, 3)
+      conventions = lines.join(' | ')
+    }
+
+    // Check for anti-patterns
+    const hasAntiPatterns = content.toLowerCase().includes('anti-pattern')
+
+    let summary = 'Code patterns loaded'
+    if (conventions) summary += ` | ${conventions.substring(0, 100)}`
+    if (hasAntiPatterns) summary += ' | Has anti-patterns'
+
+    return summary
+  }
+
+  /**
+   * Generic compression
+   */
+  private compressGeneric(content: string): string {
+    // Take first meaningful lines
+    const lines = content.split('\n').filter((l) => l.trim() && !l.startsWith('#'))
+    const preview = lines.slice(0, 2).join(' | ')
+
+    if (preview.length > 150) {
+      return preview.substring(0, 150) + '...'
+    }
+
+    return preview || 'Content available'
+  }
+
+  /**
+   * Get compression metrics
+   */
+  getMetrics(): CompressionMetrics {
+    return { ...this.metrics }
+  }
+
+  /**
+   * Reset metrics
+   */
+  resetMetrics(): void {
+    this.metrics = {
+      totalOriginal: 0,
+      totalCompressed: 0,
+      overallRatio: 1,
+      compressions: 0,
+    }
+  }
+}
+
+const semanticCompression = new SemanticCompression()
+export default semanticCompression
+export { SemanticCompression }

package/core/agentic/services.ts

@@ -0,0 +1,206 @@
+/**
+ * Agentic Services Facade
+ *
+ * Single entry point for all agentic subsystems.
+ * Use this facade instead of importing individual modules.
+ *
+ * This reduces the number of imports Claude needs to understand
+ * and provides a clear API for the agentic system.
+ *
+ * @example
+ * ```typescript
+ * import { services } from './services'
+ *
+ * // Instead of:
+ * import templateLoader from './template-loader'
+ * import contextBuilder from './context-builder'
+ * // ... 12 more imports
+ *
+ * // Use:
+ * const template = await services.templates.load('now')
+ * const context = await services.context.build(projectPath)
+ * ```
+ */
+
+import templateLoader from './template-loader'
+import contextBuilder from './context-builder'
+import promptBuilder from './prompt-builder'
+import toolRegistry from './tool-registry'
+import loopDetector from './loop-detector'
+import memorySystem from './memory-system'
+import groundTruth from './ground-truth'
+import semanticCompression from './semantic-compression'
+import responseTemplates from './response-templates'
+import chainOfThought from './chain-of-thought'
+import thinkBlocks from './think-blocks'
+import parallelTools from './parallel-tools'
+import planMode from './plan-mode'
+import contextFilter from './context-filter'
+import validationRules from './validation-rules'
+import agentRouter from './agent-router'
+import smartContext from './smart-context'
+import stateManager from '../state'
+import { outcomeRecorder, outcomeAnalyzer } from '../outcomes'
+import { agentPerformanceTracker } from '../agents'
+
+/**
+ * Agentic services interface.
+ * Each property provides access to a subsystem.
+ */
+export interface AgenticServices {
+  /**
+   * Template loader - loads command templates from templates/
+   * @see templateLoader
+   */
+  templates: typeof templateLoader
+
+  /**
+   * Context builder - builds ProjectContext for commands
+   * @see contextBuilder
+   */
+  context: typeof contextBuilder
+
+  /**
+   * Prompt builder - generates prompts from templates and context
+   * @see promptBuilder
+   */
+  prompts: typeof promptBuilder
+
+  /**
+   * Tool registry - registers and executes tools (Read, Write, Bash, etc.)
+   * @see toolRegistry
+   */
+  tools: typeof toolRegistry
+
+  /**
+   * Loop detector - detects and prevents infinite loops
+   * @see loopDetector
+   */
+  loops: typeof loopDetector
+
+  /**
+   * Memory system - stores and retrieves learned patterns
+   * @see memorySystem
+   */
+  memory: typeof memorySystem
+
+  /**
+   * Ground truth - verifies command preconditions
+   * @see groundTruth
+   */
+  truth: typeof groundTruth
+
+  /**
+   * Semantic compression - compresses context to fit token limits
+   * @see semanticCompression
+   */
+  compression: typeof semanticCompression
+
+  /**
+   * Response templates - generates formatted responses
+   * @see responseTemplates
+   */
+  responses: typeof responseTemplates
+
+  /**
+   * Chain of thought - adds reasoning to responses
+   * @see chainOfThought
+   */
+  reasoning: typeof chainOfThought
+
+  /**
+   * Think blocks - generates think block content
+   * @see thinkBlocks
+   */
+  thinking: typeof thinkBlocks
+
+  /**
+   * Parallel tools - executes tools in parallel
+   * @see parallelTools
+   */
+  parallel: typeof parallelTools
+
+  /**
+   * Plan mode - handles planning workflow
+   * @see planMode
+   */
+  planning: typeof planMode
+
+  /**
+   * Context filter - filters context for relevance
+   * @see contextFilter
+   */
+  filter: typeof contextFilter
+
+  /**
+   * Validation rules - validates command inputs
+   * @see validationRules
+   */
+  validation: typeof validationRules
+
+  /**
+   * Agent router - routes tasks to appropriate agents
+   * @see agentRouter
+   */
+  router: typeof agentRouter
+
+  /**
+   * Smart context - intelligent context filtering by task type
+   * @see smartContext
+   */
+  smartContext: typeof smartContext
+
+  /**
+   * State manager - unified project state (read/write state.json)
+   * @see stateManager
+   */
+  state: typeof stateManager
+
+  /**
+   * Outcome recorder - records execution outcomes
+   * @see outcomeRecorder
+   */
+  outcomes: typeof outcomeRecorder
+
+  /**
+   * Outcome analyzer - analyzes outcomes for patterns
+   * @see outcomeAnalyzer
+   */
+  outcomeAnalysis: typeof outcomeAnalyzer
+
+  /**
+   * Agent performance tracker - tracks agent performance
+   * @see agentPerformanceTracker
+   */
+  agentPerformance: typeof agentPerformanceTracker
+}
+
+/**
+ * Singleton services instance.
+ * Import and use this instead of individual module imports.
+ */
+export const services: AgenticServices = {
+  templates: templateLoader,
+  context: contextBuilder,
+  prompts: promptBuilder,
+  tools: toolRegistry,
+  loops: loopDetector,
+  memory: memorySystem,
+  truth: groundTruth,
+  compression: semanticCompression,
+  responses: responseTemplates,
+  reasoning: chainOfThought,
+  thinking: thinkBlocks,
+  parallel: parallelTools,
+  planning: planMode,
+  filter: contextFilter,
+  validation: validationRules,
+  router: agentRouter,
+  smartContext: smartContext,
+  state: stateManager,
+  outcomes: outcomeRecorder,
+  outcomeAnalysis: outcomeAnalyzer,
+  agentPerformance: agentPerformanceTracker,
+}
+
+export default services