prjct-cli 0.15.1 → 0.17.0

package/core/domain/architect-session.ts

@@ -1,315 +0,0 @@
-/**
- * Architect Session Manager
- * Handles conversational state for ARCHITECT MODE (Agent-based, not deterministic)
- */
-
-import fs from 'fs/promises'
-import path from 'path'
-
-interface ConversationEntry {
-  question: string
-  answer: string
-  timestamp: string
-}
-
-interface ArchitectSessionData {
-  idea: string
-  projectType: string
-  active: boolean
-  startedAt: string
-  completedAt?: string
-  conversation: ConversationEntry[]
-  answers: Record<string, string>
-}
-
-interface SessionSummary {
-  idea: string
-  projectType: string
-  conversationLength: number
-  insights: number
-  startedAt: string
-  completedAt: string
-}
-
-class ArchitectSession {
-  /**
-   * Initialize new architect session
-   */
-  async init(idea: string, projectType: string, globalPath: string): Promise<ArchitectSessionData> {
-    const session: ArchitectSessionData = {
-      idea,
-      projectType,
-      active: true,
-      startedAt: new Date().toISOString(),
-      conversation: [],
-      answers: {},
-    }
-
-    await this.save(session, globalPath)
-    return session
-  }
-
-  /**
-   * Load active session
-   */
-  async load(globalPath: string): Promise<ArchitectSessionData | null> {
-    try {
-      const sessionPath = path.join(globalPath, 'planning', 'architect-session.json')
-      const content = await fs.readFile(sessionPath, 'utf-8')
-      return JSON.parse(content)
-    } catch {
-      return null
-    }
-  }
-
-  /**
-   * Save session to disk
-   */
-  async save(session: ArchitectSessionData, globalPath: string): Promise<void> {
-    const planningDir = path.join(globalPath, 'planning')
-    await fs.mkdir(planningDir, { recursive: true })
-
-    const sessionPath = path.join(planningDir, 'architect-session.json')
-    await fs.writeFile(sessionPath, JSON.stringify(session, null, 2))
-  }
-
-  /**
-   * Log a Q&A pair to the conversation
-   */
-  async logQA(question: string, answer: string, globalPath: string): Promise<void> {
-    const session = await this.load(globalPath)
-
-    if (!session || !session.active) {
-      throw new Error('No active architect session')
-    }
-
-    session.conversation.push({
-      question,
-      answer,
-      timestamp: new Date().toISOString(),
-    })
-
-    await this.save(session, globalPath)
-  }
-
-  /**
-   * Save key insight for plan generation
-   */
-  async saveInsight(key: string, value: string, globalPath: string): Promise<void> {
-    const session = await this.load(globalPath)
-
-    if (!session || !session.active) {
-      throw new Error('No active architect session')
-    }
-
-    session.answers[key] = value
-    await this.save(session, globalPath)
-  }
-
-  /**
-   * Complete session and generate plan
-   */
-  async complete(globalPath: string): Promise<SessionSummary> {
-    const session = await this.load(globalPath)
-
-    if (!session || !session.active) {
-      throw new Error('No active architect session')
-    }
-
-    // Generate plan MD
-    await this.generatePlan(session, globalPath)
-
-    // Mark session as complete
-    session.active = false
-    session.completedAt = new Date().toISOString()
-    await this.save(session, globalPath)
-
-    return this.buildSummary(session)
-  }
-
-  /**
-   * Generate architect plan MD file
-   */
-  async generatePlan(session: ArchitectSessionData, globalPath: string): Promise<void> {
-    const plan = this.buildPlanMarkdown(session)
-
-    const planPath = path.join(globalPath, 'planning', 'architect-session.md')
-    await fs.writeFile(planPath, plan)
-  }
-
-  /**
-   * Build plan markdown content
-   */
-  buildPlanMarkdown(session: ArchitectSessionData): string {
-    const { projectType, idea, conversation, answers } = session
-
-    // Build conversation log
-    const conversationLog = conversation
-      .map((qa, i) => `### Q${i + 1}: ${qa.question}\n**A**: ${qa.answer}\n\n_${qa.timestamp}_`)
-      .join('\n\n')
-
-    // Build stack summary from answers
-    const stackSummary = this.buildStackSummary(answers)
-
-    // Build Context7 queries
-    const context7Queries = this.buildContext7Queries(answers)
-
-    // Build implementation steps
-    const steps = this.buildImplementationSteps(session)
-
-    return `# ARCHITECT SESSION: ${idea}
-
-## Project Idea
-${idea}
-
-## Project Type
-${projectType}
-
-## Discovery Conversation
-
-${conversationLog}
-
-## Architecture Summary
-
-**Stack:**
-${stackSummary}
-
-## Implementation Plan
-
-**Context7 Queries:**
-${context7Queries.map((q) => `- "${q}"`).join('\n')}
-
-**Implementation Steps:**
-${steps.map((step, i) => `${i + 1}. ${step}`).join('\n')}
-
-## Execution
-
-This plan is ready to be executed.
-
-**To generate code:**
-\`\`\`
-/p:architect execute
-\`\`\`
-
-The agent will:
-1. Read this architectural plan
-2. Use Context7 to fetch official documentation
-3. Generate project structure following best practices
-4. Create starter files with boilerplate code
-
----
-Generated: ${new Date().toISOString()}
-`
-  }
-
-  /**
-   * Build stack summary from answers
-   */
-  buildStackSummary(answers: Record<string, string>): string {
-    const parts: string[] = []
-
-    for (const [key, value] of Object.entries(answers)) {
-      if (value && value !== 'Ninguna' && value !== 'None' && value !== 'Otro') {
-        parts.push(`- **${key}**: ${value}`)
-      }
-    }
-
-    return parts.length > 0 ? parts.join('\n') : '- To be determined during implementation'
-  }
-
-  /**
-   * Build Context7 queries from answers
-   */
-  buildContext7Queries(answers: Record<string, string>): string[] {
-    const queries: string[] = []
-
-    if (answers.framework) {
-      queries.push(`${answers.framework} getting started`)
-      queries.push(`${answers.framework} project structure`)
-    }
-
-    if (answers.language && answers.framework) {
-      queries.push(`${answers.language} ${answers.framework} best practices`)
-    }
-
-    if (answers.database && answers.language) {
-      queries.push(`${answers.database} ${answers.language} integration`)
-    }
-
-    if (answers.auth) {
-      queries.push(`${answers.auth} implementation ${answers.language || ''}`.trim())
-    }
-
-    // Always include general queries if specific ones not available
-    if (queries.length === 0 && answers.language) {
-      queries.push(`${answers.language} project structure`)
-      queries.push(`${answers.language} best practices`)
-    }
-
-    return queries
-  }
-
-  /**
-   * Build implementation steps from session
-   */
-  buildImplementationSteps(session: ArchitectSessionData): string[] {
-    const { answers } = session
-    const steps: string[] = []
-
-    // Generic steps - Claude will refine during execution
-    if (answers.language) {
-      steps.push(`Initialize ${answers.language} project`)
-    }
-
-    if (answers.framework) {
-      steps.push(`Setup ${answers.framework}`)
-    }
-
-    if (answers.database) {
-      steps.push(`Configure ${answers.database}`)
-    }
-
-    if (answers.auth) {
-      steps.push(`Implement ${answers.auth}`)
-    }
-
-    steps.push('Create project structure')
-    steps.push('Generate starter files')
-
-    if (answers.deployment) {
-      steps.push(`Setup ${answers.deployment} configuration`)
-    }
-
-    return steps
-  }
-
-  /**
-   * Build summary of session
-   */
-  buildSummary(session: ArchitectSessionData): SessionSummary {
-    return {
-      idea: session.idea,
-      projectType: session.projectType,
-      conversationLength: session.conversation.length,
-      insights: Object.keys(session.answers).length,
-      startedAt: session.startedAt,
-      completedAt: session.completedAt || new Date().toISOString(),
-    }
-  }
-
-  /**
-   * Clear architect session
-   */
-  async clear(globalPath: string): Promise<void> {
-    try {
-      const sessionPath = path.join(globalPath, 'planning', 'architect-session.json')
-      await fs.unlink(sessionPath)
-    } catch {
-      // Ignore if doesn't exist
-    }
-  }
-}
-
-const architectSession = new ArchitectSession()
-export default architectSession
-export { ArchitectSession }

package/core/domain/product-standards.ts

@@ -1,106 +0,0 @@
-/**
- * Modern Product Standards
- * Defines what "Good" looks like for each domain.
- * Used to inject high standards into agent prompts.
- */
-
-interface DomainStandard {
-  title: string
-  rules: string[]
-}
-
-interface Standards {
-  title: string
-  rules: string[]
-}
-
-interface ProductStandardsType {
-  general: string[]
-  domains: Record<string, DomainStandard>
-  getStandards(domain?: string): Standards
-}
-
-const ProductStandards: ProductStandardsType = {
-  // General standards applicable to all agents
-  general: [
-    'SHIP IT: Bias for action. Better to ship and iterate than perfect and delay.',
-    'USER CENTRIC: Always ask "How does this help the user?"',
-    'CLEAN CODE: Write code that is easy to read, test, and maintain.',
-    'NO BS: Avoid over-engineering. Simple is better than complex.',
-  ],
-
-  // Domain-specific standards
-  domains: {
-    frontend: {
-      title: 'Modern Frontend Standards',
-      rules: [
-        'PERFORMANCE: Core Web Vitals matter. Optimize LCP, CLS, FID.',
-        'ACCESSIBILITY: Semantic HTML, ARIA labels, keyboard navigation (WCAG 2.1 AA).',
-        'RESPONSIVE: Mobile-first design. Works on all devices.',
-        'UX/UI: Smooth transitions, loading states, error boundaries. No dead clicks.',
-        'STATE: Local state for UI, Global state (Context/Zustand) for data. No prop drilling.',
-      ],
-    },
-    backend: {
-      title: 'Robust Backend Standards',
-      rules: [
-        'SECURITY: Validate ALL inputs. Sanitize outputs. OWASP Top 10 awareness.',
-        'SCALABILITY: Stateless services. Caching strategies (Redis/CDN).',
-        'RELIABILITY: Graceful error handling. Structured logging. Health checks.',
-        'API DESIGN: RESTful or GraphQL best practices. Consistent response envelopes.',
-        'DB: Indexed queries. Migrations for schema changes. No N+1 queries.',
-      ],
-    },
-    database: {
-      title: 'Data Integrity Standards',
-      rules: [
-        'INTEGRITY: Foreign keys, constraints, transactions.',
-        'PERFORMANCE: Index usage analysis. Query optimization.',
-        'BACKUPS: Point-in-time recovery awareness.',
-        'MIGRATIONS: Idempotent scripts. Zero-downtime changes.',
-      ],
-    },
-    devops: {
-      title: 'Modern Ops Standards',
-      rules: [
-        'AUTOMATION: CI/CD for everything. No manual deployments.',
-        'IaC: Infrastructure as Code (Terraform/Pulumi).',
-        'OBSERVABILITY: Metrics, Logs, Traces (OpenTelemetry).',
-        'SECURITY: Least privilege access. Secrets management.',
-      ],
-    },
-    qa: {
-      title: 'Quality Assurance Standards',
-      rules: [
-        'PYRAMID: Many unit tests, some integration, few E2E.',
-        'COVERAGE: Critical paths must be tested.',
-        'REALISM: Test with realistic data and scenarios.',
-        'SPEED: Fast feedback loops. Parallel execution.',
-      ],
-    },
-    architecture: {
-      title: 'System Architecture Standards',
-      rules: [
-        'MODULARITY: High cohesion, low coupling.',
-        'EVOLVABILITY: Easy to change. Hard to break.',
-        'SIMPLICITY: Choose boring technology. Innovation tokens are limited.',
-        'DOCS: Architecture Decision Records (ADRs).',
-      ],
-    },
-  },
-
-  /**
-   * Get standards for a specific domain
-   */
-  getStandards(domain?: string): Standards {
-    const key = domain?.toLowerCase()
-    const specific = (key && this.domains[key]) || { title: 'General Standards', rules: [] }
-
-    return {
-      title: specific.title,
-      rules: [...this.general, ...specific.rules],
-    }
-  },
-}
-
-export default ProductStandards

package/core/domain/smart-cache.ts

@@ -1,167 +0,0 @@
-/**
- * SmartCache - Intelligent Persistent Cache for Agents
- *
- * Cache with specific keys: {projectId}-{domain}-{techStack}
- * Persists to disk for cross-session caching
- * Invalidates only when stack changes
- *
- * @version 1.0.0
- */
-
-import fs from 'fs/promises'
-import path from 'path'
-import os from 'os'
-import crypto from 'crypto'
-import log from '../utils/logger'
-
-interface CacheStats {
-  size: number
-  keys: string[]
-}
-
-class SmartCache {
-  projectId: string | null
-  memoryCache: Map<string, unknown>
-  cacheDir: string
-  cacheFile: string
-
-  constructor(projectId: string | null = null) {
-    this.projectId = projectId
-    this.memoryCache = new Map()
-    this.cacheDir = path.join(os.homedir(), '.prjct-cli', 'cache')
-    this.cacheFile = projectId
-      ? path.join(this.cacheDir, `agents-${projectId}.json`)
-      : path.join(this.cacheDir, 'agents-global.json')
-  }
-
-  /**
-   * Initialize cache - load from disk
-   */
-  async initialize(): Promise<void> {
-    try {
-      await fs.mkdir(this.cacheDir, { recursive: true })
-      await this.loadFromDisk()
-    } catch {
-      // Cache file doesn't exist yet - that's ok
-      this.memoryCache = new Map()
-    }
-  }
-
-  /**
-   * Generate cache key
-   * Format: {projectId}-{domain}-{techStackHash}
-   */
-  generateKey(projectId: string | null, domain: string, techStack: Record<string, unknown> = {}): string {
-    const techString = JSON.stringify(techStack)
-    const techHash = crypto.createHash('md5').update(techString).digest('hex').substring(0, 8)
-    return `${projectId || 'global'}-${domain}-${techHash}`
-  }
-
-  /**
-   * Get from cache
-   */
-  async get<T = unknown>(key: string): Promise<T | null> {
-    // Check memory first
-    if (this.memoryCache.has(key)) {
-      return this.memoryCache.get(key) as T
-    }
-
-    // Load from disk if not in memory
-    await this.loadFromDisk()
-    return (this.memoryCache.get(key) as T) || null
-  }
-
-  /**
-   * Set in cache
-   */
-  async set(key: string, value: unknown): Promise<void> {
-    // Set in memory
-    this.memoryCache.set(key, value)
-
-    // Persist to disk (async, don't wait)
-    this.persistToDisk().catch((err) => {
-      log.error('Cache persist error:', err.message)
-    })
-  }
-
-  /**
-   * Check if key exists
-   */
-  async has(key: string): Promise<boolean> {
-    if (this.memoryCache.has(key)) {
-      return true
-    }
-
-    await this.loadFromDisk()
-    return this.memoryCache.has(key)
-  }
-
-  /**
-   * Clear cache
-   */
-  async clear(): Promise<void> {
-    this.memoryCache.clear()
-    try {
-      await fs.unlink(this.cacheFile)
-    } catch {
-      // File doesn't exist - that's ok
-    }
-  }
-
-  /**
-   * Invalidate cache for a project (when stack changes)
-   */
-  async invalidateProject(projectId: string): Promise<void> {
-    const keysToDelete: string[] = []
-    for (const key of this.memoryCache.keys()) {
-      if (key.startsWith(`${projectId}-`)) {
-        keysToDelete.push(key)
-      }
-    }
-
-    keysToDelete.forEach((key) => this.memoryCache.delete(key))
-    await this.persistToDisk()
-  }
-
-  /**
-   * Load cache from disk
-   */
-  async loadFromDisk(): Promise<void> {
-    try {
-      const content = await fs.readFile(this.cacheFile, 'utf-8')
-      const data = JSON.parse(content) as Record<string, unknown>
-
-      // Restore to memory cache
-      for (const [key, value] of Object.entries(data)) {
-        this.memoryCache.set(key, value)
-      }
-    } catch {
-      // File doesn't exist or invalid - start fresh
-      this.memoryCache = new Map()
-    }
-  }
-
-  /**
-   * Persist cache to disk
-   */
-  async persistToDisk(): Promise<void> {
-    try {
-      const data = Object.fromEntries(this.memoryCache)
-      await fs.writeFile(this.cacheFile, JSON.stringify(data, null, 2), 'utf-8')
-    } catch {
-      // Fail silently - cache is best effort
-    }
-  }
-
-  /**
-   * Get cache statistics
-   */
-  getStats(): CacheStats {
-    return {
-      size: this.memoryCache.size,
-      keys: Array.from(this.memoryCache.keys()),
-    }
-  }
-}
-
-export default SmartCache