prjct-cli 0.11.5 → 0.12.1

package/core/domain/{architect-session.js → architect-session.ts}

@@ -3,25 +3,46 @@
  * Handles conversational state for ARCHITECT MODE (Agent-based, not deterministic)
  */
 
-const fs = require('fs').promises
-const path = require('path')
+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
-   * @param {string} idea - Project idea
-   * @param {string} projectType - Type of project (web, api, mobile, cli, data)
-   * @param {string} globalPath - Global project path
-   * @returns {Promise<Object>} Session object
    */
-  async init(idea, projectType, globalPath) {
-    const session = {
+  async init(idea: string, projectType: string, globalPath: string): Promise<ArchitectSessionData> {
+    const session: ArchitectSessionData = {
       idea,
       projectType,
       active: true,
       startedAt: new Date().toISOString(),
-      conversation: [], // Free-form Q&A logging
-      answers: {}, // Key insights for plan generation
+      conversation: [],
+      answers: {},
     }
 
     await this.save(session, globalPath)
@@ -31,7 +52,7 @@ class ArchitectSession {
   /**
    * Load active session
    */
-  async load(globalPath) {
+  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')
@@ -44,7 +65,7 @@ class ArchitectSession {
   /**
    * Save session to disk
    */
-  async save(session, globalPath) {
+  async save(session: ArchitectSessionData, globalPath: string): Promise<void> {
     const planningDir = path.join(globalPath, 'planning')
     await fs.mkdir(planningDir, { recursive: true })
 
@@ -54,11 +75,8 @@ class ArchitectSession {
 
   /**
    * Log a Q&A pair to the conversation
-   * @param {string} question - The question asked by Claude
-   * @param {string} answer - User's answer
-   * @param {string} globalPath - Global project path
    */
-  async logQA(question, answer, globalPath) {
+  async logQA(question: string, answer: string, globalPath: string): Promise<void> {
     const session = await this.load(globalPath)
 
     if (!session || !session.active) {
@@ -76,11 +94,8 @@ class ArchitectSession {
 
   /**
    * Save key insight for plan generation
-   * @param {string} key - Insight key (e.g., 'language', 'framework', 'database')
-   * @param {string} value - Insight value
-   * @param {string} globalPath - Global project path
    */
-  async saveInsight(key, value, globalPath) {
+  async saveInsight(key: string, value: string, globalPath: string): Promise<void> {
     const session = await this.load(globalPath)
 
     if (!session || !session.active) {
@@ -93,10 +108,8 @@ class ArchitectSession {
 
   /**
    * Complete session and generate plan
-   * @param {string} globalPath - Global project path
-   * @returns {Promise<Object>} Summary object
    */
-  async complete(globalPath) {
+  async complete(globalPath: string): Promise<SessionSummary> {
     const session = await this.load(globalPath)
 
     if (!session || !session.active) {
@@ -117,7 +130,7 @@ class ArchitectSession {
   /**
    * Generate architect plan MD file
    */
-  async generatePlan(session, globalPath) {
+  async generatePlan(session: ArchitectSessionData, globalPath: string): Promise<void> {
     const plan = this.buildPlanMarkdown(session)
 
     const planPath = path.join(globalPath, 'planning', 'architect-session.md')
@@ -127,7 +140,7 @@ class ArchitectSession {
   /**
    * Build plan markdown content
    */
-  buildPlanMarkdown(session) {
+  buildPlanMarkdown(session: ArchitectSessionData): string {
     const { projectType, idea, conversation, answers } = session
 
     // Build conversation log
@@ -192,8 +205,8 @@ Generated: ${new Date().toISOString()}
   /**
    * Build stack summary from answers
    */
-  buildStackSummary(answers) {
-    const parts = []
+  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') {
@@ -207,8 +220,8 @@ Generated: ${new Date().toISOString()}
   /**
    * Build Context7 queries from answers
    */
-  buildContext7Queries(answers) {
-    const queries = []
+  buildContext7Queries(answers: Record<string, string>): string[] {
+    const queries: string[] = []
 
     if (answers.framework) {
       queries.push(`${answers.framework} getting started`)
@@ -239,9 +252,9 @@ Generated: ${new Date().toISOString()}
   /**
    * Build implementation steps from session
    */
-  buildImplementationSteps(session) {
+  buildImplementationSteps(session: ArchitectSessionData): string[] {
     const { answers } = session
-    const steps = []
+    const steps: string[] = []
 
     // Generic steps - Claude will refine during execution
     if (answers.language) {
@@ -273,7 +286,7 @@ Generated: ${new Date().toISOString()}
   /**
    * Build summary of session
    */
-  buildSummary(session) {
+  buildSummary(session: ArchitectSessionData): SessionSummary {
     return {
       idea: session.idea,
       projectType: session.projectType,
@@ -287,7 +300,7 @@ Generated: ${new Date().toISOString()}
   /**
    * Clear architect session
    */
-  async clear(globalPath) {
+  async clear(globalPath: string): Promise<void> {
     try {
       const sessionPath = path.join(globalPath, 'planning', 'architect-session.json')
       await fs.unlink(sessionPath)
@@ -297,4 +310,6 @@ Generated: ${new Date().toISOString()}
   }
 }
 
-module.exports = new ArchitectSession()
+const architectSession = new ArchitectSession()
+export default architectSession
+export { ArchitectSession }

package/core/domain/{architecture-generator.js → architecture-generator.ts}

@@ -4,10 +4,24 @@
  * This file only provides structure - real content from Claude
  */
 
-const path = require('path')
-const fs = require('fs').promises
+import path from 'path'
+import fs from 'fs/promises'
+
+interface ArchitectureContext {
+  [key: string]: unknown
+}
+
+interface Architecture {
+  id: string
+  idea: string
+  createdAt: string
+  phases: Record<string, unknown>
+  _agenticNote: string
+}
 
 class ArchitectureGenerator {
+  defaultPhases: string[]
+
   constructor() {
     // AGENTIC: Phases determined by Claude via templates/architect/phases.md
     this.defaultPhases = [
@@ -25,11 +39,8 @@ class ArchitectureGenerator {
   /**
    * Generate architecture skeleton
    * AGENTIC: Claude fills in content using templates
-   * @param {string} idea - The initial idea
-   * @param {object} context - Project context
-   * @returns {Promise<object>} Architecture skeleton
    */
-  async generateArchitecture(idea, context = {}) {
+  async generateArchitecture(idea: string, context: ArchitectureContext = {}): Promise<Architecture> {
     // Return skeleton - Claude generates actual content via templates
     return {
       id: `arch-${Date.now()}`,
@@ -37,15 +48,16 @@ class ArchitectureGenerator {
       createdAt: new Date().toISOString(),
       phases: {},
       // AGENTIC: Claude populates phases using templates/architect/*.md
-      _agenticNote: 'Use templates/architect/phases.md to determine needed phases, then templates/architect/discovery.md etc for content',
+      _agenticNote:
+        'Use templates/architect/phases.md to determine needed phases, then templates/architect/discovery.md etc for content',
     }
   }
 
   /**
    * Get template path for a phase
    */
-  getPhaseTemplate(phase) {
-    const templateMap = {
+  getPhaseTemplate(phase: string): string | null {
+    const templateMap: Record<string, string> = {
       discovery: 'templates/architect/discovery.md',
       'user-flows': 'templates/design/flow.md',
       'domain-modeling': 'templates/design/database.md',
@@ -62,7 +74,7 @@ class ArchitectureGenerator {
    * Save architecture to files
    * AGENTIC: Format determined by Claude based on content
    */
-  async saveArchitecture(architecture, projectPath) {
+  async saveArchitecture(architecture: Architecture, projectPath: string): Promise<string> {
     const archPath = path.join(projectPath, 'planning', 'architectures', architecture.id)
     await fs.mkdir(archPath, { recursive: true })
 
@@ -76,8 +88,8 @@ class ArchitectureGenerator {
   /**
    * SQL type mapping utility
    */
-  sqlType(type) {
-    const typeMap = {
+  sqlType(type: string): string {
+    const typeMap: Record<string, string> = {
       uuid: 'UUID',
       string: 'VARCHAR(255)',
       text: 'TEXT',
@@ -90,4 +102,4 @@ class ArchitectureGenerator {
   }
 }
 
-module.exports = ArchitectureGenerator
+export default ArchitectureGenerator

package/core/domain/{context-estimator.js → context-estimator.ts}

@@ -1,24 +1,45 @@
 /**
  * ContextEstimator - Pre-filter files before building context
- * 
+ *
  * Estimates which files are needed based on task analysis
  * BEFORE building full context - saves I/O
- * 
+ *
  * @version 1.0.0
  */
 
-const path = require('path')
-const { glob } = require('glob')
-const log = require('../utils/logger')
+import path from 'path'
+import { glob } from 'glob'
+import log from '../utils/logger'
+
+interface TaskAnalysis {
+  primaryDomain: string
+  projectTechnologies?: ProjectTech
+  semantic?: SemanticAnalysis
+}
+
+interface ProjectTech {
+  extensions?: Record<string, number>
+  directories?: string[]
+  [key: string]: unknown
+}
+
+interface SemanticAnalysis {
+  requiresMultipleAgents?: boolean
+  agents?: string[]
+  [key: string]: unknown
+}
+
+interface FilePatterns {
+  include: string[]
+  extensions: string[]
+  exclude: string[]
+}
 
 class ContextEstimator {
   /**
    * Estimate which files are needed for a task
-   * @param {Object} taskAnalysis - Task analysis result
-   * @param {string} projectPath - Project path
-   * @returns {Promise<Array<string>>} Estimated file paths
    */
-  async estimateFiles(taskAnalysis, projectPath) {
+  async estimateFiles(taskAnalysis: TaskAnalysis, projectPath: string): Promise<string[]> {
     const domain = taskAnalysis.primaryDomain
     const projectTech = taskAnalysis.projectTechnologies || {}
     const semantic = taskAnalysis.semantic || {}
@@ -29,13 +50,16 @@ class ContextEstimator {
     // Expand with semantic understanding
     if (semantic.requiresMultipleAgents && semantic.agents) {
       // Multi-agent task - combine patterns
-      const allPatterns = semantic.agents.reduce((acc, agentDomain) => {
-        const agentPatterns = this.getPatternsForDomain(agentDomain, projectTech)
-        return {
-          include: [...acc.include, ...agentPatterns.include],
-          extensions: [...acc.extensions, ...agentPatterns.extensions]
-        }
-      }, { include: [], extensions: [] })
+      const allPatterns = semantic.agents.reduce(
+        (acc, agentDomain) => {
+          const agentPatterns = this.getPatternsForDomain(agentDomain, projectTech)
+          return {
+            include: [...acc.include, ...agentPatterns.include],
+            extensions: [...acc.extensions, ...agentPatterns.extensions],
+          }
+        },
+        { include: [] as string[], extensions: [] as string[] }
+      )
 
       patterns.include = [...new Set(allPatterns.include)]
       patterns.extensions = [...new Set(allPatterns.extensions)]
@@ -55,35 +79,33 @@ class ContextEstimator {
    * 100% AGENTIC: Uses REAL project data, not hardcoded patterns.
    * No domain-specific assumptions or language→extension mapping.
    */
-  getPatternsForDomain(domain, projectData) {
-    const patterns = {
+  getPatternsForDomain(domain: string, projectData: ProjectTech): FilePatterns {
+    const patterns: FilePatterns = {
       include: [],
       extensions: [],
-      exclude: ['node_modules', 'dist', 'build', '.git', '.next', 'target', 'vendor', 'coverage']
+      exclude: ['node_modules', 'dist', 'build', '.git', '.next', 'target', 'vendor', 'coverage'],
     }
 
     // Use REAL extensions from project (if provided in projectData)
     if (projectData && projectData.extensions) {
       // projectData.extensions is {'.js': 45, '.ts': 23, ...}
       patterns.extensions = Object.keys(projectData.extensions)
-        .filter(ext => ext.startsWith('.'))
-        .slice(0, 15); // Top 15 extensions
+        .filter((ext) => ext.startsWith('.'))
+        .slice(0, 15) // Top 15 extensions
     }
 
     // Use REAL directories from project (if provided in projectData)
     if (projectData && projectData.directories) {
-      patterns.include = projectData.directories.filter(dir =>
-        !patterns.exclude.includes(dir)
-      );
+      patterns.include = projectData.directories.filter((dir) => !patterns.exclude.includes(dir))
     }
 
     // If no real data available, use minimal universal fallback
     if (patterns.extensions.length === 0) {
-      patterns.extensions = ['*']; // All files
+      patterns.extensions = ['*'] // All files
     }
 
     if (patterns.include.length === 0) {
-      patterns.include = ['.']; // Root directory
+      patterns.include = ['.'] // Root directory
     }
 
     // NO domain-specific hardcoding
@@ -95,12 +117,12 @@ class ContextEstimator {
   /**
    * Find files matching patterns
    */
-  async findMatchingFiles(projectPath, patterns) {
-    const files = []
+  async findMatchingFiles(projectPath: string, patterns: FilePatterns): Promise<string[]> {
+    const files: string[] = []
 
     try {
       // Build glob patterns
-      const globPatterns = []
+      const globPatterns: string[] = []
 
       // Add include patterns
       for (const include of patterns.include) {
@@ -120,15 +142,15 @@ class ContextEstimator {
         try {
           const matches = await glob(pattern, {
             cwd: projectPath,
-            ignore: patterns.exclude.map(ex => `**/${ex}/**`),
+            ignore: patterns.exclude.map((ex) => `**/${ex}/**`),
             nodir: true,
-            follow: false
+            follow: false,
           })
 
           if (Array.isArray(matches)) {
             files.push(...matches)
           }
-        } catch (error) {
+        } catch {
           // Skip invalid patterns
         }
       }
@@ -136,7 +158,7 @@ class ContextEstimator {
       // Remove duplicates and sort
       return [...new Set(files)].sort()
     } catch (error) {
-      log.error('Error finding files:', error.message)
+      log.error('Error finding files:', (error as Error).message)
       return []
     }
   }
@@ -144,11 +166,10 @@ class ContextEstimator {
   /**
    * Estimate context size (number of files)
    */
-  async estimateContextSize(taskAnalysis, projectPath) {
+  async estimateContextSize(taskAnalysis: TaskAnalysis, projectPath: string): Promise<number> {
     const files = await this.estimateFiles(taskAnalysis, projectPath)
     return files.length
   }
 }
 
-module.exports = ContextEstimator
-
+export default ContextEstimator

package/core/domain/{product-standards.js → product-standards.ts}

@@ -4,13 +4,29 @@
  * Used to inject high standards into agent prompts.
  */
 
-const ProductStandards = {
+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.'
+    'NO BS: Avoid over-engineering. Simple is better than complex.',
   ],
 
   // Domain-specific standards
@@ -22,8 +38,8 @@ const ProductStandards = {
         '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.'
-      ]
+        'STATE: Local state for UI, Global state (Context/Zustand) for data. No prop drilling.',
+      ],
     },
     backend: {
       title: 'Robust Backend Standards',
@@ -32,8 +48,8 @@ const ProductStandards = {
         '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.'
-      ]
+        'DB: Indexed queries. Migrations for schema changes. No N+1 queries.',
+      ],
     },
     database: {
       title: 'Data Integrity Standards',
@@ -41,8 +57,8 @@ const ProductStandards = {
         'INTEGRITY: Foreign keys, constraints, transactions.',
         'PERFORMANCE: Index usage analysis. Query optimization.',
         'BACKUPS: Point-in-time recovery awareness.',
-        'MIGRATIONS: Idempotent scripts. Zero-downtime changes.'
-      ]
+        'MIGRATIONS: Idempotent scripts. Zero-downtime changes.',
+      ],
     },
     devops: {
       title: 'Modern Ops Standards',
@@ -50,8 +66,8 @@ const ProductStandards = {
         '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.'
-      ]
+        'SECURITY: Least privilege access. Secrets management.',
+      ],
     },
     qa: {
       title: 'Quality Assurance Standards',
@@ -59,8 +75,8 @@ const ProductStandards = {
         '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.'
-      ]
+        'SPEED: Fast feedback loops. Parallel execution.',
+      ],
     },
     architecture: {
       title: 'System Architecture Standards',
@@ -68,25 +84,23 @@ const ProductStandards = {
         '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).'
-      ]
-    }
+        'DOCS: Architecture Decision Records (ADRs).',
+      ],
+    },
   },
 
   /**
    * Get standards for a specific domain
-   * @param {string} domain - The domain (frontend, backend, etc.)
-   * @returns {Object} The standards object
    */
-  getStandards(domain) {
-    const key = domain?.toLowerCase();
-    const specific = this.domains[key] || { title: 'General Standards', rules: [] };
-    
+  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]
-    };
-  }
-};
+      rules: [...this.general, ...specific.rules],
+    }
+  },
+}
 
-module.exports = ProductStandards;
+export default ProductStandards