prjct-cli 0.11.5 → 0.12.1

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

@@ -1,23 +1,45 @@
 /**
  * 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
-   * @param {string} agentName - Proposed agent name
-   * @param {Object} config - Agent configuration
-   * @param {Array<Object>} existingAgents - Existing agents
-   * @returns {Object} Validation result
    */
-  validateBeforeGeneration(agentName, config, existingAgents = []) {
-    const issues = []
-    const warnings = []
+  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)
@@ -44,18 +66,16 @@ class AgentValidator {
       valid: issues.length === 0,
       issues,
       warnings,
-      similarAgent: similar
+      similarAgent: similar,
     }
   }
 
   /**
    * Validate agent after generation
-   * @param {Object} agent - Generated agent
-   * @returns {Object} Validation result
    */
-  validateAfterGeneration(agent) {
-    const issues = []
-    const warnings = []
+  validateAfterGeneration(agent: Agent): ValidationResult {
+    const issues: string[] = []
+    const warnings: string[] = []
 
     // Check if agent has content
     if (!agent.content || agent.content.length < 100) {
@@ -82,14 +102,14 @@ class AgentValidator {
       valid: issues.length === 0,
       issues,
       warnings,
-      usefulness
+      usefulness,
     }
   }
 
   /**
    * Find similar existing agent
    */
-  findSimilarAgent(agentName, config, existingAgents) {
+  findSimilarAgent(agentName: string, config: AgentConfig, existingAgents: Agent[]): Agent | null {
     for (const existing of existingAgents) {
       // Check name similarity
       if (this.namesSimilar(agentName, existing.name)) {
@@ -112,7 +132,7 @@ class AgentValidator {
   /**
    * Check if agent names are similar
    */
-  namesSimilar(name1, name2) {
+  namesSimilar(name1: string, name2: string): boolean {
     const n1 = name1.toLowerCase()
     const n2 = name2.toLowerCase()
 
@@ -125,7 +145,7 @@ class AgentValidator {
     // 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 intersection = new Set([...words1].filter((w) => words2.has(w)))
     const union = new Set([...words1, ...words2])
 
     return intersection.size / union.size > 0.5
@@ -134,7 +154,7 @@ class AgentValidator {
   /**
    * Calculate skill overlap between config and existing agent
    */
-  calculateSkillOverlap(config, existingAgent) {
+  calculateSkillOverlap(config: AgentConfig, existingAgent: Agent): number {
     if (!existingAgent.skills || existingAgent.skills.length === 0) {
       return 0
     }
@@ -146,10 +166,10 @@ class AgentValidator {
     }
 
     // Calculate overlap
-    const existingSet = new Set(existingAgent.skills.map(s => s.toLowerCase()))
-    const configSet = new Set(configSkills.map(s => s.toLowerCase()))
+    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 intersection = new Set([...existingSet].filter((s) => configSet.has(s)))
     const union = new Set([...existingSet, ...configSet])
 
     return intersection.size / union.size
@@ -158,27 +178,41 @@ class AgentValidator {
   /**
    * Extract skills from text
    */
-  extractSkillsFromText(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'
+      '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())
-    )
+    return techKeywords.filter((tech) => text.toLowerCase().includes(tech.toLowerCase()))
   }
 
   /**
    * Calculate agent usefulness score
    */
-  calculateUsefulness(agent) {
+  calculateUsefulness(agent: Agent): number {
     let score = 0
 
     // Has skills
@@ -213,5 +247,4 @@ class AgentValidator {
   }
 }
 
-module.exports = AgentValidator
-
+export default AgentValidator

package/core/domain/{analyzer.js → analyzer.ts}

@@ -1,9 +1,3 @@
-const fs = require('fs').promises
-const path = require('path')
-const { promisify } = require('util')
-const { exec: execCallback } = require('child_process')
-const exec = promisify(execCallback)
-
 /**
  * CodebaseAnalyzer - Provides helpers for project analysis
  *
@@ -15,26 +9,56 @@ const exec = promisify(execCallback)
  *
  * @version 0.6.0 - Fully agentic refactor
  */
+
+import fs from 'fs/promises'
+import path from 'path'
+import { promisify } from 'util'
+import { exec as execCallback } from 'child_process'
+
+const exec = promisify(execCallback)
+
+interface PackageJson {
+  name?: string
+  version?: string
+  dependencies?: Record<string, string>
+  devDependencies?: Record<string, string>
+  scripts?: Record<string, string>
+  [key: string]: unknown
+}
+
+interface ComposerJson {
+  name?: string
+  require?: Record<string, string>
+  'require-dev'?: Record<string, string>
+  [key: string]: unknown
+}
+
+interface GitStats {
+  totalCommits: number
+  contributors: number
+  age: string
+}
+
+interface FileExtensions {
+  [extension: string]: number
+}
+
 class CodebaseAnalyzer {
-  constructor() {
-    this.projectPath = null
-  }
+  projectPath: string | null = null
 
   /**
    * Initialize analyzer for a project
-   * @param {string} projectPath - Project path
    */
-  init(projectPath = process.cwd()) {
+  init(projectPath: string = process.cwd()): void {
     this.projectPath = projectPath
   }
 
   /**
    * Read package.json if it exists
-   * @returns {Promise<Object|null>}
    */
-  async readPackageJson() {
+  async readPackageJson(): Promise<PackageJson | null> {
     try {
-      const packagePath = path.join(this.projectPath, 'package.json')
+      const packagePath = path.join(this.projectPath!, 'package.json')
       const content = await fs.readFile(packagePath, 'utf-8')
       return JSON.parse(content)
     } catch {
@@ -44,11 +68,10 @@ class CodebaseAnalyzer {
 
   /**
    * Read Cargo.toml if it exists
-   * @returns {Promise<string|null>}
    */
-  async readCargoToml() {
+  async readCargoToml(): Promise<string | null> {
     try {
-      const cargoPath = path.join(this.projectPath, 'Cargo.toml')
+      const cargoPath = path.join(this.projectPath!, 'Cargo.toml')
       return await fs.readFile(cargoPath, 'utf-8')
     } catch {
       return null
@@ -57,11 +80,10 @@ class CodebaseAnalyzer {
 
   /**
    * Read requirements.txt if it exists
-   * @returns {Promise<string|null>}
    */
-  async readRequirements() {
+  async readRequirements(): Promise<string | null> {
     try {
-      const reqPath = path.join(this.projectPath, 'requirements.txt')
+      const reqPath = path.join(this.projectPath!, 'requirements.txt')
       return await fs.readFile(reqPath, 'utf-8')
     } catch {
       return null
@@ -70,11 +92,10 @@ class CodebaseAnalyzer {
 
   /**
    * Read go.mod if it exists
-   * @returns {Promise<string|null>}
    */
-  async readGoMod() {
+  async readGoMod(): Promise<string | null> {
     try {
-      const goModPath = path.join(this.projectPath, 'go.mod')
+      const goModPath = path.join(this.projectPath!, 'go.mod')
       return await fs.readFile(goModPath, 'utf-8')
     } catch {
       return null
@@ -83,11 +104,10 @@ class CodebaseAnalyzer {
 
   /**
    * Read Gemfile if it exists (Ruby)
-   * @returns {Promise<string|null>}
    */
-  async readGemfile() {
+  async readGemfile(): Promise<string | null> {
     try {
-      const gemfilePath = path.join(this.projectPath, 'Gemfile')
+      const gemfilePath = path.join(this.projectPath!, 'Gemfile')
       return await fs.readFile(gemfilePath, 'utf-8')
     } catch {
       return null
@@ -96,11 +116,10 @@ class CodebaseAnalyzer {
 
   /**
    * Read mix.exs if it exists (Elixir)
-   * @returns {Promise<string|null>}
    */
-  async readMixExs() {
+  async readMixExs(): Promise<string | null> {
     try {
-      const mixPath = path.join(this.projectPath, 'mix.exs')
+      const mixPath = path.join(this.projectPath!, 'mix.exs')
       return await fs.readFile(mixPath, 'utf-8')
     } catch {
       return null
@@ -109,11 +128,10 @@ class CodebaseAnalyzer {
 
   /**
    * Read pom.xml if it exists (Java/Maven)
-   * @returns {Promise<string|null>}
    */
-  async readPomXml() {
+  async readPomXml(): Promise<string | null> {
     try {
-      const pomPath = path.join(this.projectPath, 'pom.xml')
+      const pomPath = path.join(this.projectPath!, 'pom.xml')
       return await fs.readFile(pomPath, 'utf-8')
     } catch {
       return null
@@ -122,11 +140,10 @@ class CodebaseAnalyzer {
 
   /**
    * Read composer.json if it exists (PHP)
-   * @returns {Promise<Object|null>}
    */
-  async readComposerJson() {
+  async readComposerJson(): Promise<ComposerJson | null> {
     try {
-      const composerPath = path.join(this.projectPath, 'composer.json')
+      const composerPath = path.join(this.projectPath!, 'composer.json')
       const content = await fs.readFile(composerPath, 'utf-8')
       return JSON.parse(content)
     } catch {
@@ -136,11 +153,10 @@ class CodebaseAnalyzer {
 
   /**
    * Read pyproject.toml if it exists (Python)
-   * @returns {Promise<string|null>}
    */
-  async readPyprojectToml() {
+  async readPyprojectToml(): Promise<string | null> {
     try {
-      const pyprojectPath = path.join(this.projectPath, 'pyproject.toml')
+      const pyprojectPath = path.join(this.projectPath!, 'pyproject.toml')
       return await fs.readFile(pyprojectPath, 'utf-8')
     } catch {
       return null
@@ -150,21 +166,24 @@ class CodebaseAnalyzer {
   /**
    * Get all file extensions in project with counts
    * I/O PURO - Solo cuenta, no interpreta
-   * @returns {Promise<Object>} - {'.js': 45, '.ts': 23, ...}
    */
-  async getFileExtensions() {
+  async getFileExtensions(): Promise<FileExtensions> {
     try {
       const { stdout } = await exec(
         'find . -type f ! -path "*/node_modules/*" ! -path "*/.git/*" ! -path "*/dist/*" ! -path "*/.next/*" | sed "s/.*\\./\\./" | sort | uniq -c | sort -rn',
-        { cwd: this.projectPath }
+        { cwd: this.projectPath! }
       )
-      const extensions = {}
-      stdout.trim().split('\n').filter(Boolean).forEach(line => {
-        const match = line.trim().match(/^\s*(\d+)\s+(\.\w+)$/)
-        if (match) {
-          extensions[match[2]] = parseInt(match[1])
-        }
-      })
+      const extensions: FileExtensions = {}
+      stdout
+        .trim()
+        .split('\n')
+        .filter(Boolean)
+        .forEach((line) => {
+          const match = line.trim().match(/^\s*(\d+)\s+(\.\w+)$/)
+          if (match) {
+            extensions[match[2]] = parseInt(match[1])
+          }
+        })
       return extensions
     } catch {
       return {}
@@ -174,11 +193,10 @@ class CodebaseAnalyzer {
   /**
    * List all config files in project root
    * I/O PURO - Solo lista, no categoriza
-   * @returns {Promise<string[]>}
    */
-  async listConfigFiles() {
+  async listConfigFiles(): Promise<string[]> {
     try {
-      const entries = await fs.readdir(this.projectPath)
+      const entries = await fs.readdir(this.projectPath!)
       const configPatterns = [
         /^package\.json$/,
         /^Cargo\.toml$/,
@@ -195,9 +213,7 @@ class CodebaseAnalyzer {
         /^docker-compose.*\.ya?ml$/,
         /^\.env.*$/,
       ]
-      return entries.filter(entry =>
-        configPatterns.some(pattern => pattern.test(entry))
-      )
+      return entries.filter((entry) => configPatterns.some((pattern) => pattern.test(entry)))
     } catch {
       return []
     }
@@ -205,11 +221,10 @@ class CodebaseAnalyzer {
 
   /**
    * List all directories in project root
-   * @returns {Promise<string[]>}
    */
-  async listDirectories() {
+  async listDirectories(): Promise<string[]> {
     try {
-      const entries = await fs.readdir(this.projectPath, { withFileTypes: true })
+      const entries = await fs.readdir(this.projectPath!, { withFileTypes: true })
       return entries
         .filter((entry) => entry.isDirectory())
         .map((entry) => entry.name)
@@ -221,13 +236,11 @@ class CodebaseAnalyzer {
 
   /**
    * Get git log (last N commits)
-   * @param {number} limit - Number of commits
-   * @returns {Promise<string>}
    */
-  async getGitLog(limit = 50) {
+  async getGitLog(limit: number = 50): Promise<string> {
     try {
       const { stdout } = await exec(`git log -n ${limit} --pretty=format:"%h|%an|%ar|%s"`, {
-        cwd: this.projectPath,
+        cwd: this.projectPath!,
       })
       return stdout
     } catch {
@@ -237,22 +250,20 @@ class CodebaseAnalyzer {
 
   /**
    * Get git statistics
-   * @returns {Promise<Object>}
    */
-  async getGitStats() {
+  async getGitStats(): Promise<GitStats> {
     try {
       const { stdout: totalCommits } = await exec('git rev-list --count HEAD', {
-        cwd: this.projectPath,
+        cwd: this.projectPath!,
       })
 
       const { stdout: contributors } = await exec('git log --format="%an" | sort -u | wc -l', {
-        cwd: this.projectPath,
+        cwd: this.projectPath!,
       })
 
-      const { stdout: firstCommit } = await exec(
-        'git log --reverse --pretty=format:"%ar" | head -1',
-        { cwd: this.projectPath }
-      )
+      const { stdout: firstCommit } = await exec('git log --reverse --pretty=format:"%ar" | head -1', {
+        cwd: this.projectPath!,
+      })
 
       return {
         totalCommits: parseInt(totalCommits.trim()) || 0,
@@ -270,13 +281,12 @@ class CodebaseAnalyzer {
 
   /**
    * Count total files (excluding common ignore patterns)
-   * @returns {Promise<number>}
    */
-  async countFiles() {
+  async countFiles(): Promise<number> {
     try {
       const { stdout } = await exec(
         'find . -type f ! -path "*/node_modules/*" ! -path "*/.git/*" ! -path "*/dist/*" | wc -l',
-        { cwd: this.projectPath }
+        { cwd: this.projectPath! }
       )
       return parseInt(stdout.trim()) || 0
     } catch {
@@ -286,12 +296,10 @@ class CodebaseAnalyzer {
 
   /**
    * Check if file exists
-   * @param {string} filename - Filename to check
-   * @returns {Promise<boolean>}
    */
-  async fileExists(filename) {
+  async fileExists(filename: string): Promise<boolean> {
     try {
-      await fs.access(path.join(this.projectPath, filename))
+      await fs.access(path.join(this.projectPath!, filename))
       return true
     } catch {
       return false
@@ -300,12 +308,10 @@ class CodebaseAnalyzer {
 
   /**
    * Read any file in the project
-   * @param {string} relativePath - Path relative to project root
-   * @returns {Promise<string|null>}
    */
-  async readFile(relativePath) {
+  async readFile(relativePath: string): Promise<string | null> {
     try {
-      const fullPath = path.join(this.projectPath, relativePath)
+      const fullPath = path.join(this.projectPath!, relativePath)
       return await fs.readFile(fullPath, 'utf-8')
     } catch {
       return null
@@ -314,14 +320,12 @@ class CodebaseAnalyzer {
 
   /**
    * Find files matching a pattern
-   * @param {string} pattern - Glob pattern
-   * @returns {Promise<string[]>}
    */
-  async findFiles(pattern) {
+  async findFiles(pattern: string): Promise<string[]> {
     try {
       const { stdout } = await exec(
         `find . -type f -name "${pattern}" ! -path "*/node_modules/*" ! -path "*/.git/*"`,
-        { cwd: this.projectPath }
+        { cwd: this.projectPath! }
       )
       return stdout.trim().split('\n').filter(Boolean)
     } catch {
@@ -330,4 +334,6 @@ class CodebaseAnalyzer {
   }
 }
 
-module.exports = new CodebaseAnalyzer()
+const analyzer = new CodebaseAnalyzer()
+export default analyzer
+export { CodebaseAnalyzer }