prjct-cli 1.21.0 → 1.23.0

package/core/agentic/response-validator.ts

@@ -1,98 +0,0 @@
-/**
- * Response Validator
- *
- * Validates LLM responses against Zod schemas.
- * Provides structured error handling with re-prompt support.
- *
- * Flow:
- * 1. Parse raw text as JSON
- * 2. Validate against Zod schema
- * 3. On success: return typed data
- * 4. On failure: return validation errors for re-prompt or fallback
- *
- * @see PRJ-264
- */
-
-import type { z } from 'zod'
-
-// =============================================================================
-// Types
-// =============================================================================
-
-export interface ValidationSuccess<T> {
-  success: true
-  data: T
-}
-
-export interface ValidationFailure {
-  success: false
-  error: string
-  /** Raw parsed JSON (may be partial) */
-  rawParsed: unknown
-  /** Zod validation issues */
-  issues: string[]
-}
-
-export type ValidationResult<T> = ValidationSuccess<T> | ValidationFailure
-
-// =============================================================================
-// Core Validation
-// =============================================================================
-
-/**
- * Validate a raw LLM response string against a Zod schema.
- *
- * Handles:
- * - JSON parse errors (LLM returned non-JSON)
- * - Markdown-wrapped JSON (```json ... ```)
- * - Schema validation errors (wrong fields, types)
- */
-export function validateLLMResponse<T>(raw: string, schema: z.ZodType<T>): ValidationResult<T> {
-  // Strip markdown code fences if present
-  let jsonText = raw.trim()
-  const fenceMatch = jsonText.match(/^```(?:json)?\s*\n?([\s\S]*?)\n?\s*```$/)
-  if (fenceMatch) {
-    jsonText = fenceMatch[1].trim()
-  }
-
-  // Attempt JSON parse
-  let parsed: unknown
-  try {
-    parsed = JSON.parse(jsonText)
-  } catch {
-    return {
-      success: false,
-      error: 'Response is not valid JSON',
-      rawParsed: null,
-      issues: [`JSON parse error: expected JSON, got: ${jsonText.slice(0, 100)}...`],
-    }
-  }
-
-  // Validate against schema
-  const result = schema.safeParse(parsed)
-  if (result.success) {
-    return { success: true, data: result.data }
-  }
-
-  // Extract readable error messages
-  const issues = result.error.issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`)
-
-  return {
-    success: false,
-    error: `Schema validation failed: ${issues.join('; ')}`,
-    rawParsed: parsed,
-    issues,
-  }
-}
-
-/**
- * Build a re-prompt message when validation fails.
- * Includes the original error so the LLM can fix its response.
- */
-export function buildReprompt(failure: ValidationFailure, schemaExample: string): string {
-  return `Your previous response was not valid. Errors:
-${failure.issues.map((i) => `- ${i}`).join('\n')}
-
-Return ONLY valid JSON matching this exact format (no markdown, no explanation):
-${schemaExample}`
-}

package/core/agentic/services.ts

@@ -1,167 +0,0 @@
-/**
- * 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 * as 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 { outcomeAnalyzer, outcomeRecorder } from '../outcomes'
-import { ideasStorage, queueStorage, shippedStorage, stateStorage } from '../storage'
-import agentRouter from './agent-router'
-import chainOfThought from './chain-of-thought'
-import contextBuilder from './context-builder'
-import groundTruth from './ground-truth'
-import loopDetector from './loop-detector'
-import memorySystem from './memory-system'
-import planMode from './plan-mode'
-import promptBuilder from './prompt-builder'
-import smartContext from './smart-context'
-import templateLoader from './template-loader'
-import toolRegistry from './tool-registry'
-
-// Storage managers object (replaces mdManagers)
-const storageManagers = {
-  state: stateStorage,
-  queue: queueStorage,
-  ideas: ideasStorage,
-  shipped: shippedStorage,
-}
-
-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
-
-  /**
-   * Chain of thought - adds reasoning to responses
-   * @see chainOfThought
-   */
-  reasoning: typeof chainOfThought
-
-  /**
-   * Plan mode - handles planning workflow
-   * @see planMode
-   */
-  planning: typeof planMode
-
-  /**
-   * 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
-
-  /**
-   * Storage managers - Write-through state management
-   * @see storageManagers
-   */
-  data: typeof storageManagers
-
-  /**
-   * 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,
-  reasoning: chainOfThought,
-  planning: planMode,
-  router: agentRouter,
-  smartContext: smartContext,
-  data: storageManagers,
-  outcomes: outcomeRecorder,
-  outcomeAnalysis: outcomeAnalyzer,
-  agentPerformance: agentPerformanceTracker,
-}
-
-export default services

package/core/agentic/skill-loader.ts

@@ -1,106 +0,0 @@
-/**
- * Skill Loader for Agentic System
- *
- * Integrates skills into the prompt builder and context system.
- * Formats skills for Claude consumption.
- *
- * @version 1.0.0
- */
-
-import skillService from '../services/skill-service'
-import type { FormattedSkill, Skill, SkillContext } from '../types'
-
-/**
- * Format a skill for inclusion in prompts
- */
-function formatSkillForPrompt(skill: Skill): FormattedSkill {
-  return {
-    id: skill.id,
-    name: skill.name,
-    description: skill.description,
-    prompt: skill.content,
-  }
-}
-
-/**
- * Generate markdown listing of available skills
- */
-function generateSkillsMarkdown(skills: Skill[]): string {
-  if (skills.length === 0) {
-    return ''
-  }
-
-  const lines: string[] = ['## Available Skills', '', 'The following skills can be invoked:', '']
-
-  for (const skill of skills) {
-    lines.push(`- **${skill.name}** (\`${skill.id}\`): ${skill.description || 'No description'}`)
-    if (skill.metadata.agent) {
-      lines.push(`  - Agent: ${skill.metadata.agent}`)
-    }
-    if (skill.metadata.tags?.length) {
-      lines.push(`  - Tags: ${skill.metadata.tags.join(', ')}`)
-    }
-  }
-
-  return lines.join('\n')
-}
-
-/**
- * Load skills and prepare context for prompts
- */
-export async function loadSkillContext(projectPath?: string): Promise<SkillContext> {
-  const skills = await skillService.getAll(projectPath)
-
-  return {
-    availableSkills: skills.map(formatSkillForPrompt),
-    skillsMarkdown: generateSkillsMarkdown(skills),
-  }
-}
-
-/**
- * Get a specific skill's prompt content
- */
-export async function getSkillPrompt(
-  skillId: string,
-  projectPath?: string
-): Promise<string | null> {
-  const skill = await skillService.get(skillId, projectPath)
-  return skill?.content || null
-}
-
-/**
- * Find best matching skill for a query
- */
-export async function findBestSkill(query: string, projectPath?: string): Promise<Skill | null> {
-  const results = await skillService.search(query, projectPath)
-  return results[0]?.skill || null
-}
-
-/**
- * Format skill invocation result
- */
-export function formatSkillResult(skill: Skill, result: string): string {
-  return [
-    `## Skill Executed: ${skill.name}`,
-    '',
-    result,
-    '',
-    `---`,
-    `*Skill: ${skill.id} | Source: ${skill.source}*`,
-  ].join('\n')
-}
-
-/**
- * Build skill section for system prompt
- */
-export async function buildSkillSystemPrompt(projectPath?: string): Promise<string> {
-  const { availableSkills, skillsMarkdown } = await loadSkillContext(projectPath)
-
-  if (availableSkills.length === 0) {
-    return ''
-  }
-
-  return ['<skills>', skillsMarkdown, '', 'To invoke a skill, use the skill ID.', '</skills>'].join(
-    '\n'
-  )
-}