prjct-cli 0.15.1 → 0.18.0

package/core/agentic/validation-rules.ts

@@ -1,313 +0,0 @@
-/**
- * Validation Rules
- * Pre-flight validation for commands before execution
- *
- * @module agentic/validation-rules
- * @version 1.0.0
- */
-
-import fs from 'fs/promises'
-import path from 'path'
-import os from 'os'
-
-interface Context {
-  projectPath: string
-  projectId?: string | null
-  paths: Record<string, string>
-  params: Record<string, unknown>
-}
-
-interface ValidationResult {
-  valid: boolean
-  errors: string[]
-  warnings: string[]
-  suggestions: string[]
-}
-
-type Validator = (context: Context) => Promise<ValidationResult>
-
-/**
- * Command-specific validators
- */
-const validators: Record<string, Validator> = {
-  /**
-   * Validate /p:done can execute
-   */
-  async done(context): Promise<ValidationResult> {
-    const errors: string[] = []
-    const warnings: string[] = []
-    const suggestions: string[] = []
-
-    // Check if now.md exists and has content
-    try {
-      const nowContent = await fs.readFile(context.paths.now, 'utf-8')
-      if (!nowContent.trim() || nowContent.includes('No current task')) {
-        errors.push('No active task to complete')
-        suggestions.push('Start a task with /p:now "task description"')
-      }
-    } catch {
-      errors.push('now.md does not exist')
-      suggestions.push('Initialize project with /p:init')
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors,
-      warnings,
-      suggestions,
-    }
-  },
-
-  /**
-   * Validate /p:ship can execute
-   */
-  async ship(context): Promise<ValidationResult> {
-    const errors: string[] = []
-    const warnings: string[] = []
-    const suggestions: string[] = []
-
-    // Check if now.md has content to ship
-    try {
-      const nowContent = await fs.readFile(context.paths.now, 'utf-8')
-      if (!nowContent.trim() || nowContent.includes('No current task')) {
-        warnings.push('No active task to ship')
-      }
-    } catch {
-      warnings.push('now.md does not exist')
-    }
-
-    // Check if shipped.md exists
-    try {
-      await fs.access(path.dirname(context.paths.shipped))
-    } catch {
-      warnings.push('shipped.md directory does not exist')
-      suggestions.push('Run /p:init to initialize project structure')
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors,
-      warnings,
-      suggestions,
-    }
-  },
-
-  /**
-   * Validate /p:now can execute
-   */
-  async now(context): Promise<ValidationResult> {
-    const errors: string[] = []
-    const warnings: string[] = []
-    const suggestions: string[] = []
-
-    // Check if project is initialized
-    const configPath = path.join(context.projectPath, '.prjct/prjct.config.json')
-    try {
-      await fs.access(configPath)
-    } catch {
-      errors.push('Project not initialized')
-      suggestions.push('Run /p:init to initialize')
-    }
-
-    // Check if already has a task
-    try {
-      const nowContent = await fs.readFile(context.paths.now, 'utf-8')
-      if (nowContent.trim() && !nowContent.includes('No current task')) {
-        warnings.push('Already has an active task')
-        suggestions.push('Complete it first with /p:done')
-      }
-    } catch {
-      // now.md doesn't exist - that's ok for /p:now
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors,
-      warnings,
-      suggestions,
-    }
-  },
-
-  /**
-   * Validate /p:init can execute
-   */
-  async init(context): Promise<ValidationResult> {
-    const errors: string[] = []
-    const warnings: string[] = []
-    const suggestions: string[] = []
-
-    // Check if already initialized
-    const configPath = path.join(context.projectPath, '.prjct/prjct.config.json')
-    try {
-      await fs.access(configPath)
-      warnings.push('Project already initialized')
-      suggestions.push('Use /p:sync to refresh or delete .prjct/ to reinitialize')
-    } catch {
-      // Not initialized - good
-    }
-
-    // Check if global storage is writable
-    const globalPath = path.join(os.homedir(), '.prjct-cli')
-    try {
-      await fs.mkdir(globalPath, { recursive: true })
-    } catch {
-      errors.push('Cannot create ~/.prjct-cli directory')
-      suggestions.push('Check filesystem permissions')
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors,
-      warnings,
-      suggestions,
-    }
-  },
-
-  /**
-   * Validate /p:sync can execute
-   */
-  async sync(context): Promise<ValidationResult> {
-    const errors: string[] = []
-    const warnings: string[] = []
-    const suggestions: string[] = []
-
-    // Check if project is initialized
-    const configPath = path.join(context.projectPath, '.prjct/prjct.config.json')
-    try {
-      await fs.access(configPath)
-    } catch {
-      errors.push('Project not initialized')
-      suggestions.push('Run /p:init first')
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors,
-      warnings,
-      suggestions,
-    }
-  },
-
-  /**
-   * Validate /p:feature can execute
-   */
-  async feature(context): Promise<ValidationResult> {
-    const errors: string[] = []
-    const warnings: string[] = []
-    const suggestions: string[] = []
-
-    // Check if project is initialized
-    const configPath = path.join(context.projectPath, '.prjct/prjct.config.json')
-    try {
-      await fs.access(configPath)
-    } catch {
-      errors.push('Project not initialized')
-      suggestions.push('Run /p:init first')
-    }
-
-    // Check if description provided
-    if (!context.params.description && !context.params.feature) {
-      warnings.push('No feature description provided')
-      suggestions.push('Provide a feature description')
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors,
-      warnings,
-      suggestions,
-    }
-  },
-
-  /**
-   * Validate /p:idea can execute
-   */
-  async idea(context): Promise<ValidationResult> {
-    const errors: string[] = []
-    const warnings: string[] = []
-    const suggestions: string[] = []
-
-    // Check if project is initialized
-    const configPath = path.join(context.projectPath, '.prjct/prjct.config.json')
-    try {
-      await fs.access(configPath)
-    } catch {
-      errors.push('Project not initialized')
-      suggestions.push('Run /p:init first')
-    }
-
-    // Check if idea text provided
-    if (!context.params.idea && !context.params.text) {
-      warnings.push('No idea text provided')
-      suggestions.push('Provide idea text')
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors,
-      warnings,
-      suggestions,
-    }
-  },
-}
-
-/**
- * Validate a command before execution
- */
-async function validate(commandName: string, context: Context): Promise<ValidationResult> {
-  const validator = validators[commandName]
-
-  if (!validator) {
-    // No specific validation needed
-    return {
-      valid: true,
-      errors: [],
-      warnings: [],
-      suggestions: [],
-    }
-  }
-
-  try {
-    return await validator(context)
-  } catch (error) {
-    return {
-      valid: false,
-      errors: [`Validation error: ${(error as Error).message}`],
-      warnings: [],
-      suggestions: ['Check file permissions and project configuration'],
-    }
-  }
-}
-
-/**
- * Format validation errors for display
- */
-function formatError(result: ValidationResult): string {
-  let output = ''
-
-  if (result.errors.length > 0) {
-    output += '❌ Validation Failed:\n'
-    result.errors.forEach((e) => {
-      output += `  • ${e}\n`
-    })
-  }
-
-  if (result.warnings.length > 0) {
-    output += '\n⚠️  Warnings:\n'
-    result.warnings.forEach((w) => {
-      output += `  • ${w}\n`
-    })
-  }
-
-  if (result.suggestions.length > 0) {
-    output += '\n💡 Suggestions:\n'
-    result.suggestions.forEach((s) => {
-      output += `  → ${s}\n`
-    })
-  }
-
-  return output
-}
-
-export { validate, formatError, validators }
-export default { validate, formatError, validators }

package/core/domain/agent-matcher.ts

@@ -1,130 +0,0 @@
-/**
- * AgentMatcher - Orchestration Only
- *
- * AGENTIC: All matching decisions made by Claude via templates/agent-assignment.md
- * JS only orchestrates: format data, pass to Claude, return result
- *
- * NO scoring logic, NO algorithms, NO hardcoded weights
- *
- * @version 2.0.0
- */
-
-import fs from 'fs/promises'
-import path from 'path'
-
-interface Agent {
-  name: string
-  domain?: string
-  content?: string
-}
-
-interface Task {
-  description?: string
-  type?: string
-}
-
-interface HistoryEntry {
-  timestamp: string
-  agent: string
-  task: string
-}
-
-interface FormattedAgent {
-  name: string
-  domain: string
-  hasContent: boolean
-}
-
-interface FormattedTask {
-  description: string
-  type: string
-}
-
-class AgentMatcher {
-  historyPath: string | null = null
-
-  /**
-   * Set history path for logging
-   * ORCHESTRATION: Path setup only
-   */
-  setHistoryPath(projectId: string): void {
-    this.historyPath = path.join(
-      process.env.HOME || '',
-      '.prjct-cli',
-      'projects',
-      projectId,
-      'agent-history.jsonl'
-    )
-  }
-
-  /**
-   * Format agents for Claude
-   * ORCHESTRATION: Data formatting only
-   */
-  formatAgentsForTemplate(agents: Agent[]): FormattedAgent[] {
-    return agents.map((a) => ({
-      name: a.name,
-      domain: a.domain || 'general',
-      hasContent: !!a.content,
-    }))
-  }
-
-  /**
-   * Format task for Claude
-   * ORCHESTRATION: Data formatting only
-   */
-  formatTaskForTemplate(task: string | Task): FormattedTask {
-    return {
-      description: typeof task === 'string' ? task : task.description || '',
-      type: typeof task === 'string' ? 'unknown' : task.type || 'unknown',
-    }
-  }
-
-  /**
-   * Record agent usage
-   * ORCHESTRATION: File I/O only
-   */
-  async recordUsage(agent: string | Agent, task: string | Task): Promise<void> {
-    if (!this.historyPath) return
-
-    try {
-      const entry =
-        JSON.stringify({
-          timestamp: new Date().toISOString(),
-          agent: typeof agent === 'string' ? agent : agent.name,
-          task: typeof task === 'string' ? task : task.description,
-        }) + '\n'
-
-      await fs.appendFile(this.historyPath, entry)
-    } catch {
-      // Silent fail
-    }
-  }
-
-  /**
-   * Load usage history
-   * ORCHESTRATION: File I/O only
-   */
-  async loadHistory(): Promise<HistoryEntry[]> {
-    if (!this.historyPath) return []
-
-    try {
-      const content = await fs.readFile(this.historyPath, 'utf-8')
-      return content
-        .split('\n')
-        .filter(Boolean)
-        .map((line) => {
-          try {
-            return JSON.parse(line) as HistoryEntry
-          } catch {
-            return null
-          }
-        })
-        .filter((entry): entry is HistoryEntry => entry !== null)
-    } catch {
-      return []
-    }
-  }
-}
-
-export default AgentMatcher

package/core/domain/agent-validator.ts

@@ -1,250 +0,0 @@
-/**
- * AgentValidator - Validates agents before and after generation
- *
- * Ensures agents are useful and not generic
- * Compares with existing agents before generating
- *
- * @version 1.0.0
- */
-
-interface AgentConfig {
-  expertise?: string
-  domain?: string
-  projectContext?: Record<string, unknown>
-}
-
-interface Agent {
-  name: string
-  content?: string
-  skills?: string[]
-  domain?: string
-  role?: string
-}
-
-interface ValidationResult {
-  valid: boolean
-  issues: string[]
-  warnings: string[]
-  similarAgent?: Agent | null
-  usefulness?: number
-}
-
-class AgentValidator {
-  /**
-   * Validate if agent should be generated
-   */
-  validateBeforeGeneration(
-    agentName: string,
-    config: AgentConfig,
-    existingAgents: Agent[] = []
-  ): ValidationResult {
-    const issues: string[] = []
-    const warnings: string[] = []
-
-    // Check if similar agent exists
-    const similar = this.findSimilarAgent(agentName, config, existingAgents)
-    if (similar) {
-      warnings.push(`Similar agent exists: ${similar.name}`)
-    }
-
-    // Check if agent has specific skills
-    if (!config.expertise || config.expertise.length < 10) {
-      issues.push('Agent expertise is too generic')
-    }
-
-    // Check if agent has project context
-    if (!config.projectContext || Object.keys(config.projectContext).length === 0) {
-      warnings.push('Agent has no project-specific context')
-    }
-
-    // Check if agent name is descriptive
-    if (agentName.includes('specialist') && !config.expertise) {
-      issues.push('Agent name suggests specialization but has no expertise defined')
-    }
-
-    return {
-      valid: issues.length === 0,
-      issues,
-      warnings,
-      similarAgent: similar,
-    }
-  }
-
-  /**
-   * Validate agent after generation
-   */
-  validateAfterGeneration(agent: Agent): ValidationResult {
-    const issues: string[] = []
-    const warnings: string[] = []
-
-    // Check if agent has content
-    if (!agent.content || agent.content.length < 100) {
-      issues.push('Agent content is too short or missing')
-    }
-
-    // Check if agent has skills extracted
-    if (!agent.skills || agent.skills.length === 0) {
-      warnings.push('Agent has no skills detected')
-    }
-
-    // Check if agent has domain
-    if (!agent.domain || agent.domain === 'general') {
-      warnings.push('Agent domain is generic')
-    }
-
-    // Check if agent is useful (not too generic)
-    const usefulness = this.calculateUsefulness(agent)
-    if (usefulness < 0.5) {
-      issues.push('Agent is too generic to be useful')
-    }
-
-    return {
-      valid: issues.length === 0,
-      issues,
-      warnings,
-      usefulness,
-    }
-  }
-
-  /**
-   * Find similar existing agent
-   */
-  findSimilarAgent(agentName: string, config: AgentConfig, existingAgents: Agent[]): Agent | null {
-    for (const existing of existingAgents) {
-      // Check name similarity
-      if (this.namesSimilar(agentName, existing.name)) {
-        return existing
-      }
-
-      // Check domain similarity
-      if (config.domain && existing.domain && config.domain === existing.domain) {
-        // Check if skills overlap significantly
-        const skillOverlap = this.calculateSkillOverlap(config, existing)
-        if (skillOverlap > 0.7) {
-          return existing
-        }
-      }
-    }
-
-    return null
-  }
-
-  /**
-   * Check if agent names are similar
-   */
-  namesSimilar(name1: string, name2: string): boolean {
-    const n1 = name1.toLowerCase()
-    const n2 = name2.toLowerCase()
-
-    // Exact match
-    if (n1 === n2) return true
-
-    // One contains the other
-    if (n1.includes(n2) || n2.includes(n1)) return true
-
-    // Check word overlap
-    const words1 = new Set(n1.split('-'))
-    const words2 = new Set(n2.split('-'))
-    const intersection = new Set([...words1].filter((w) => words2.has(w)))
-    const union = new Set([...words1, ...words2])
-
-    return intersection.size / union.size > 0.5
-  }
-
-  /**
-   * Calculate skill overlap between config and existing agent
-   */
-  calculateSkillOverlap(config: AgentConfig, existingAgent: Agent): number {
-    if (!existingAgent.skills || existingAgent.skills.length === 0) {
-      return 0
-    }
-
-    // Extract skills from config expertise
-    const configSkills = this.extractSkillsFromText(config.expertise || '')
-    if (configSkills.length === 0) {
-      return 0
-    }
-
-    // Calculate overlap
-    const existingSet = new Set(existingAgent.skills.map((s) => s.toLowerCase()))
-    const configSet = new Set(configSkills.map((s) => s.toLowerCase()))
-
-    const intersection = new Set([...existingSet].filter((s) => configSet.has(s)))
-    const union = new Set([...existingSet, ...configSet])
-
-    return intersection.size / union.size
-  }
-
-  /**
-   * Extract skills from text
-   */
-  extractSkillsFromText(text: string): string[] {
-    // Common technology keywords
-    const techKeywords = [
-      'React',
-      'Vue',
-      'Angular',
-      'Svelte',
-      'Next.js',
-      'Nuxt',
-      'SvelteKit',
-      'TypeScript',
-      'JavaScript',
-      'Node.js',
-      'Express',
-      'Fastify',
-      'Python',
-      'Django',
-      'Flask',
-      'FastAPI',
-      'Go',
-      'Rust',
-      'Ruby',
-      'Rails',
-      'PostgreSQL',
-      'MySQL',
-      'MongoDB',
-    ]
-
-    return techKeywords.filter((tech) => text.toLowerCase().includes(tech.toLowerCase()))
-  }
-
-  /**
-   * Calculate agent usefulness score
-   */
-  calculateUsefulness(agent: Agent): number {
-    let score = 0
-
-    // Has skills
-    if (agent.skills && agent.skills.length > 0) {
-      score += 0.3
-      if (agent.skills.length > 3) {
-        score += 0.1 // Bonus for multiple skills
-      }
-    }
-
-    // Has specific domain
-    if (agent.domain && agent.domain !== 'general') {
-      score += 0.2
-    }
-
-    // Has content
-    if (agent.content && agent.content.length > 200) {
-      score += 0.2
-    }
-
-    // Has role
-    if (agent.role && agent.role.length > 10) {
-      score += 0.1
-    }
-
-    // Not generic name
-    if (agent.name && !agent.name.includes('generalist')) {
-      score += 0.1
-    }
-
-    return Math.min(score, 1.0)
-  }
-}
-
-export default AgentValidator