prjct-cli 0.11.5 → 0.12.1

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

@@ -1,16 +1,55 @@
-const fs = require('fs').promises
-const path = require('path')
-const os = require('os')
-const AgentLoader = require('./agent-loader')
-const log = require('../utils/logger')
-
 /**
  * AgentGenerator - Universal Dynamic Agent Generation
  * Optimized for minimal context usage
  * @version 1.0.0
  */
+
+import fs from 'fs/promises'
+import path from 'path'
+import os from 'os'
+import AgentLoader from './agent-loader'
+import log from '../utils/logger'
+
+interface AgentConfig {
+  role?: string
+  domain?: string
+  projectContext?: Record<string, unknown> | string
+  expertise?: string
+  contextFilter?: string
+}
+
+interface TechSummary {
+  languages: string[]
+  frameworks: string[]
+  buildTools: string[]
+  testFrameworks: string[]
+  databases: string[]
+  tools: string[]
+  allDependencies: string[]
+}
+
+interface GenerateContext {
+  detectedTech: TechSummary
+  analysisSummary?: string
+  projectPath?: string
+}
+
+interface Agent {
+  name: string
+  content?: string
+  path?: string
+  role?: string | null
+  domain?: string
+  skills?: string[]
+  modified?: Date
+}
+
 class AgentGenerator {
-  constructor(projectId = null) {
+  projectId: string | null
+  outputDir: string
+  loader: AgentLoader
+
+  constructor(projectId: string | null = null) {
     this.projectId = projectId
     this.outputDir = projectId
       ? path.join(os.homedir(), '.prjct-cli', 'projects', projectId, 'agents')
@@ -22,7 +61,7 @@ class AgentGenerator {
    * Generate specialized agent with deep expertise
    * Universal - works with ANY technology stack
    */
-  async generateDynamicAgent(agentName, config) {
+  async generateDynamicAgent(agentName: string, config: AgentConfig): Promise<{ name: string }> {
     log.debug(`Generating ${agentName} agent...`)
     await fs.mkdir(this.outputDir, { recursive: true })
 
@@ -41,60 +80,52 @@ class AgentGenerator {
    * Claude decides what agents are needed based on actual project tech
    * NO HARDCODED LISTS - reads analysis and decides
    */
-  async generateAgentsFromTech(context) {
-    const { detectedTech, analysisSummary, projectPath } = context
-    const agents = []
-    
+  async generateAgentsFromTech(context: GenerateContext): Promise<Array<{ name: string }>> {
+    const { detectedTech } = context
+    const agents: string[] = []
+
     // Read agent generation template - Claude will use this to decide
     const templatePath = path.join(__dirname, '../../templates/agents/AGENTS.md')
-    let agentTemplate = ''
     try {
-      agentTemplate = await fs.readFile(templatePath, 'utf-8')
+      await fs.readFile(templatePath, 'utf-8')
     } catch {
       // Fallback if template doesn't exist
-      agentTemplate = 'Generate agents based on detected technologies'
     }
-    
+
     // Build context for Claude to decide
-    // Pass full tech info, let Claude categorize and decide what agents are needed
-    const techSummary = {
+    const techSummary: TechSummary = {
       languages: detectedTech.languages || [],
       frameworks: detectedTech.frameworks || [],
       buildTools: detectedTech.buildTools || [],
       testFrameworks: detectedTech.testFrameworks || [],
       databases: detectedTech.databases || [],
       tools: detectedTech.tools || [],
-      allDependencies: detectedTech.allDependencies || []
+      allDependencies: detectedTech.allDependencies || [],
     }
-    
-    // For now, generate basic agents based on what we detected
-    // But this should be replaced with Claude decision-making
-    // TODO: Make this fully agentic by having Claude read the template and decide
-    
-    // Temporary: Generate agents for detected domains (agentic, not hardcoded)
-    // Claude will eventually decide this based on template
+
+    // Generate agents for detected domains
     if (techSummary.languages.length > 0 || techSummary.frameworks.length > 0) {
-      // Generate a general development agent
       await this.generateDynamicAgent('developer', {
         role: 'Development Specialist',
         domain: 'general',
-        projectContext: techSummary
+        projectContext: techSummary,
       })
       agents.push('developer')
     }
-    
-    return agents.map(name => ({ name }))
+
+    return agents.map((name) => ({ name }))
   }
 
   /**
    * Build comprehensive agent prompt
    */
-  buildAgentPrompt(agentName, config) {
-    const domain = config.domain || 'general';
-    
-    const projectContext = (typeof config.projectContext === 'object')
-      ? JSON.stringify(config.projectContext || {}, null, 2)
-      : (config.projectContext || 'No specific project context provided.');
+  buildAgentPrompt(agentName: string, config: AgentConfig): string {
+    const domain = config.domain || 'general'
+
+    const projectContext =
+      typeof config.projectContext === 'object'
+        ? JSON.stringify(config.projectContext || {}, null, 2)
+        : config.projectContext || 'No specific project context provided.'
 
     return `# AGENT: ${agentName.toUpperCase()}
 Role: ${config.role || agentName}
@@ -133,16 +164,14 @@ ${config.contextFilter || 'Only relevant files'}
 - Do not assume a specific stack until you see the code.
 - Optimize for production.
 - No explanations unless asked.
-`;
+`
   }
 
   /**
    * Remove agents that are no longer needed
-   * @param {Array} requiredAgents - List of agents that should exist
-   * @returns {Promise<Array>} List of removed agents
    */
-  async cleanupObsoleteAgents(requiredAgents) {
-    const removed = []
+  async cleanupObsoleteAgents(requiredAgents: string[]): Promise<string[]> {
+    const removed: string[] = []
 
     try {
       const files = await fs.readdir(this.outputDir)
@@ -159,7 +188,7 @@ ${config.contextFilter || 'Only relevant files'}
         }
       }
     } catch (error) {
-      log.error('Agent cleanup failed:', error.message)
+      log.error('Agent cleanup failed:', (error as Error).message)
     }
 
     return removed
@@ -167,14 +196,11 @@ ${config.contextFilter || 'Only relevant files'}
 
   /**
    * List all existing agents
-   * @returns {Promise<Array>} List of agent names
    */
-  async listAgents() {
+  async listAgents(): Promise<string[]> {
     try {
       const files = await fs.readdir(this.outputDir)
-      return files
-        .filter((f) => f.endsWith('.md') && !f.startsWith('.'))
-        .map((f) => f.replace('.md', ''))
+      return files.filter((f) => f.endsWith('.md') && !f.startsWith('.')).map((f) => f.replace('.md', ''))
     } catch {
       return []
     }
@@ -182,30 +208,24 @@ ${config.contextFilter || 'Only relevant files'}
 
   /**
    * Load an agent from its file
-   * CRITICAL: This is how agents are actually used in prompts
-   * @param {string} agentName - Name of the agent (without .md extension)
-   * @returns {Promise<Object|null>} - Agent object with name, content, role, domain, skills, or null if not found
    */
-  async loadAgent(agentName) {
+  async loadAgent(agentName: string): Promise<Agent | null> {
     return await this.loader.loadAgent(agentName)
   }
 
   /**
    * Load all agents for the project
-   * @returns {Promise<Array<Object>>} - Array of agent objects
    */
-  async loadAllAgents() {
+  async loadAllAgents(): Promise<Agent[]> {
     return await this.loader.loadAllAgents()
   }
 
   /**
    * Check if an agent exists
-   * @param {string} agentName - Name of the agent
-   * @returns {Promise<boolean>} - True if agent file exists
    */
-  async agentExists(agentName) {
+  async agentExists(agentName: string): Promise<boolean> {
     return await this.loader.agentExists(agentName)
   }
 }
 
-module.exports = AgentGenerator
+export default AgentGenerator

package/core/domain/{agent-loader.js → agent-loader.ts}

@@ -1,17 +1,31 @@
 /**
  * AgentLoader - Loads agents from project files
- * 
+ *
  * CRITICAL: This ensures agents generated for a project are actually USED
- * 
+ *
  * @version 1.0.0
  */
 
-const fs = require('fs').promises
-const path = require('path')
-const os = require('os')
+import fs from 'fs/promises'
+import path from 'path'
+import os from 'os'
+
+interface Agent {
+  name: string
+  content: string
+  path: string
+  role: string | null
+  domain: string
+  skills: string[]
+  modified: Date
+}
 
 class AgentLoader {
-  constructor(projectId = null) {
+  projectId: string | null
+  agentsDir: string
+  cache: Map<string, Agent>
+
+  constructor(projectId: string | null = null) {
     this.projectId = projectId
     this.agentsDir = projectId
       ? path.join(os.homedir(), '.prjct-cli', 'projects', projectId, 'agents')
@@ -21,14 +35,12 @@ class AgentLoader {
 
   /**
    * Load an agent from its file
-   * @param {string} agentName - Name of the agent (without .md extension)
-   * @returns {Promise<Object|null>} - Agent object with name and content, or null if not found
    */
-  async loadAgent(agentName) {
+  async loadAgent(agentName: string): Promise<Agent | null> {
     // Check cache first
     const cacheKey = `${this.projectId || 'global'}-${agentName}`
     if (this.cache.has(cacheKey)) {
-      return this.cache.get(cacheKey)
+      return this.cache.get(cacheKey)!
     }
 
     try {
@@ -36,18 +48,14 @@ class AgentLoader {
       const content = await fs.readFile(agentPath, 'utf-8')
 
       // Parse agent metadata from content
-      const agent = {
+      const agent: Agent = {
         name: agentName,
         content,
         path: agentPath,
-        // Extract role if present in content
         role: this.extractRole(content),
-        // Extract domain if present
         domain: this.extractDomain(content),
-        // Extract skills/technologies mentioned
         skills: this.extractSkills(content),
-        // Last modified time
-        modified: (await fs.stat(agentPath)).mtime
+        modified: (await fs.stat(agentPath)).mtime,
       }
 
       // Cache it
@@ -55,7 +63,7 @@ class AgentLoader {
 
       return agent
     } catch (error) {
-      if (error.code === 'ENOENT') {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
         return null // Agent file doesn't exist
       }
       throw error
@@ -64,14 +72,13 @@ class AgentLoader {
 
   /**
    * Load all agents for the project
-   * @returns {Promise<Array<Object>>} - Array of agent objects
    */
-  async loadAllAgents() {
+  async loadAllAgents(): Promise<Agent[]> {
     try {
       const files = await fs.readdir(this.agentsDir)
-      const agentFiles = files.filter(f => f.endsWith('.md') && !f.startsWith('.'))
+      const agentFiles = files.filter((f) => f.endsWith('.md') && !f.startsWith('.'))
 
-      const agents = []
+      const agents: Agent[] = []
       for (const file of agentFiles) {
         const agentName = file.replace('.md', '')
         const agent = await this.loadAgent(agentName)
@@ -82,7 +89,7 @@ class AgentLoader {
 
       return agents
     } catch (error) {
-      if (error.code === 'ENOENT') {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
         return [] // Agents directory doesn't exist yet
       }
       throw error
@@ -91,10 +98,8 @@ class AgentLoader {
 
   /**
    * Check if an agent exists
-   * @param {string} agentName - Name of the agent
-   * @returns {Promise<boolean>} - True if agent file exists
    */
-  async agentExists(agentName) {
+  async agentExists(agentName: string): Promise<boolean> {
     try {
       const agentPath = path.join(this.agentsDir, `${agentName}.md`)
       await fs.access(agentPath)
@@ -107,58 +112,64 @@ class AgentLoader {
   /**
    * Clear cache (useful after agent updates)
    */
-  clearCache() {
+  clearCache(): void {
     this.cache.clear()
   }
 
   /**
    * Extract role from agent content
-   * @private
    */
-  extractRole(content) {
+  private extractRole(content: string): string | null {
     const roleMatch = content.match(/Role:\s*(.+)/i)
     return roleMatch ? roleMatch[1].trim() : null
   }
 
   /**
    * Extract domain from agent content
-   * @private
    */
-  extractDomain(content) {
+  private extractDomain(content: string): string {
     const domainMatch = content.match(/DOMAIN AUTHORITY[\s\S]*?the\s+(\w+)\s+domain/i)
     if (domainMatch) {
       return domainMatch[1].toLowerCase()
     }
-    
-    // Fallback: try to detect from agent name
-    const name = this.projectId ? '' : ''
-    if (name.includes('frontend')) return 'frontend'
-    if (name.includes('backend')) return 'backend'
-    if (name.includes('database')) return 'database'
-    if (name.includes('devops')) return 'devops'
-    if (name.includes('qa')) return 'qa'
-    if (name.includes('architect')) return 'architecture'
-    
+
     return 'general'
   }
 
   /**
    * Extract skills/technologies mentioned in agent content
-   * @private
    */
-  extractSkills(content) {
-    const skills = []
-    
+  private extractSkills(content: string): string[] {
+    const skills: string[] = []
+
     // Look for common technology mentions
     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',
-      'Docker', 'Kubernetes', 'Terraform'
+      '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',
+      'Docker',
+      'Kubernetes',
+      'Terraform',
     ]
 
     for (const tech of techKeywords) {
@@ -172,12 +183,10 @@ class AgentLoader {
 
   /**
    * Get agents directory path
-   * @returns {string} - Path to agents directory
    */
-  getAgentsDir() {
+  getAgentsDir(): string {
     return this.agentsDir
   }
 }
 
-module.exports = AgentLoader
-
+export default AgentLoader

package/core/domain/{agent-matcher.js → agent-matcher.ts}

@@ -9,21 +9,47 @@
  * @version 2.0.0
  */
 
-const fs = require('fs').promises
-const path = require('path')
+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 {
-  constructor() {
-    this.historyPath = null
-  }
+  historyPath: string | null = null
 
   /**
    * Set history path for logging
    * ORCHESTRATION: Path setup only
    */
-  setHistoryPath(projectId) {
+  setHistoryPath(projectId: string): void {
     this.historyPath = path.join(
-      process.env.HOME,
+      process.env.HOME || '',
       '.prjct-cli',
       'projects',
       projectId,
@@ -35,11 +61,11 @@ class AgentMatcher {
    * Format agents for Claude
    * ORCHESTRATION: Data formatting only
    */
-  formatAgentsForTemplate(agents) {
-    return agents.map(a => ({
+  formatAgentsForTemplate(agents: Agent[]): FormattedAgent[] {
+    return agents.map((a) => ({
       name: a.name,
       domain: a.domain || 'general',
-      hasContent: !!a.content
+      hasContent: !!a.content,
     }))
   }
 
@@ -47,10 +73,10 @@ class AgentMatcher {
    * Format task for Claude
    * ORCHESTRATION: Data formatting only
    */
-  formatTaskForTemplate(task) {
+  formatTaskForTemplate(task: string | Task): FormattedTask {
     return {
-      description: typeof task === 'string' ? task : task.description,
-      type: task.type || 'unknown'
+      description: typeof task === 'string' ? task : task.description || '',
+      type: typeof task === 'string' ? 'unknown' : task.type || 'unknown',
     }
   }
 
@@ -58,15 +84,16 @@ class AgentMatcher {
    * Record agent usage
    * ORCHESTRATION: File I/O only
    */
-  async recordUsage(agent, task) {
+  async recordUsage(agent: string | Agent, task: string | Task): Promise<void> {
     if (!this.historyPath) return
 
     try {
-      const entry = JSON.stringify({
-        timestamp: new Date().toISOString(),
-        agent: agent.name || agent,
-        task: typeof task === 'string' ? task : task.description
-      }) + '\n'
+      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 {
@@ -78,7 +105,7 @@ class AgentMatcher {
    * Load usage history
    * ORCHESTRATION: File I/O only
    */
-  async loadHistory() {
+  async loadHistory(): Promise<HistoryEntry[]> {
     if (!this.historyPath) return []
 
     try {
@@ -86,18 +113,18 @@ class AgentMatcher {
       return content
         .split('\n')
         .filter(Boolean)
-        .map(line => {
+        .map((line) => {
           try {
-            return JSON.parse(line)
+            return JSON.parse(line) as HistoryEntry
           } catch {
             return null
           }
         })
-        .filter(Boolean)
+        .filter((entry): entry is HistoryEntry => entry !== null)
     } catch {
       return []
     }
   }
 }
 
-module.exports = AgentMatcher
+export default AgentMatcher