prjct-cli 0.9.1 → 0.10.0

package/core/__tests__/domain/agent-generator.test.js

@@ -6,13 +6,8 @@ import path from 'path'
 
 describe('Agent Generator', () => {
   const testProjectId = 'test-agent-gen-' + Date.now()
-  let generator
-  let agentsDir
-
-  beforeEach(() => {
-    generator = new AgentGenerator(testProjectId)
-    agentsDir = path.join(os.homedir(), '.prjct-cli', 'projects', testProjectId, 'agents')
-  })
+  const agentsDir = path.join(os.homedir(), '.prjct-cli', 'projects', testProjectId, 'agents')
+  const generator = new AgentGenerator(testProjectId)
 
   afterEach(async () => {
     // Cleanup test files
@@ -66,13 +61,10 @@ describe('Agent Generator', () => {
 
       const content = await fs.readFile(path.join(agentsDir, 'backend-agent.md'), 'utf-8')
 
-      expect(content).toContain('# Backend Developer')
-      expect(content).toContain('## Role')
-      expect(content).toContain('Backend Developer')
-      expect(content).toContain('## Expertise')
-      expect(content).toContain('Node.js, Express, PostgreSQL')
-      expect(content).toContain('## Responsibilities')
-      expect(content).toContain('API development and database management')
+      expect(content).toContain('# AGENT: BACKEND-AGENT')
+      expect(content).toContain('Role: Backend Developer')
+      expect(content).toContain('## META-INSTRUCTION')
+      // Expertise and Responsibilities are now part of the context or analysis instructions
     })
 
     it('should include project context in agent file', async () => {
@@ -88,7 +80,7 @@ describe('Agent Generator', () => {
 
       const content = await fs.readFile(path.join(agentsDir, 'context-agent.md'), 'utf-8')
 
-      expect(content).toContain('## Project Context')
+      expect(content).toContain('## PROJECT CONTEXT')
       expect(content).toContain('framework')
       expect(content).toContain('React')
       expect(content).toContain('version')
@@ -102,10 +94,10 @@ describe('Agent Generator', () => {
 
       const content = await fs.readFile(path.join(agentsDir, 'minimal-agent.md'), 'utf-8')
 
-      expect(content).toContain('# Minimal Role')
-      expect(content).toContain('Technologies used in this project')
-      expect(content).toContain('Handle specific aspects of development')
-      expect(content).toContain('No additional context')
+      expect(content).toContain('# AGENT: MINIMAL-AGENT')
+      expect(content).toContain('## META-INSTRUCTION')
+      expect(content).toContain('ANALYZE the provided PROJECT CONTEXT')
+      expect(content).toContain('No specific project context provided')
     })
 
     it('should create output directory if not exists', async () => {
@@ -149,7 +141,7 @@ describe('Agent Generator', () => {
 
       const content = await fs.readFile(path.join(agentsDir, 'fallback-agent.md'), 'utf-8')
 
-      expect(content).toContain('# fallback-agent')
+      expect(content).toContain('# AGENT: FALLBACK-AGENT')
     })
   })
 
@@ -251,17 +243,17 @@ describe('Agent Generator', () => {
       await generator.generateDynamicAgent('remove-me', { role: 'Remove' })
 
       // Verify they exist
-      let agents = await generator.listAgents()
-      expect(agents).toHaveLength(2)
+      const initialAgents = await generator.listAgents()
+      expect(initialAgents).toHaveLength(2)
 
       // Cleanup obsolete
       const removed = await generator.cleanupObsoleteAgents(['keep-me'])
       expect(removed).toContain('remove-me')
 
       // Verify cleanup
-      agents = await generator.listAgents()
-      expect(agents).toHaveLength(1)
-      expect(agents).toContain('keep-me')
+      const finalAgents = await generator.listAgents()
+      expect(finalAgents).toHaveLength(1)
+      expect(finalAgents).toContain('keep-me')
     })
 
     it('should handle agent file content correctly', async () => {
@@ -278,19 +270,20 @@ describe('Agent Generator', () => {
       const content = await fs.readFile(path.join(agentsDir, 'full-agent.md'), 'utf-8')
 
       // Should have all sections
-      expect(content).toContain('# Full Stack Developer')
-      expect(content).toContain('## Role')
-      expect(content).toContain('## Expertise')
-      expect(content).toContain('## Responsibilities')
-      expect(content).toContain('## Project Context')
-      expect(content).toContain('## Guidelines')
-
-      // Should have all content
-      expect(content).toContain('Full Stack Developer')
-      expect(content).toContain('React, Node.js, PostgreSQL, Docker')
-      expect(content).toContain('Build and deploy full stack applications')
+      expect(content).toContain('# AGENT: FULL-AGENT')
+      expect(content).toContain('Role: Full Stack Developer')
+      expect(content).toContain('## META-INSTRUCTION')
+      expect(content).toContain('## DOMAIN AUTHORITY')
+      expect(content).toContain('## DYNAMIC STANDARDS')
+      expect(content).toContain('## ORCHESTRATION PROTOCOL')
+      expect(content).toContain('## PROJECT CONTEXT')
+
+      // Should have context content
       expect(content).toContain('MERN')
       expect(content).toContain('AWS')
+      
+      // Should NOT have hardcoded tech lists anymore
+      // expect(content).toContain('React, Node.js, PostgreSQL, Docker') // This is no longer explicitly listed in EXPERTISE section as that section is gone
     })
   })
 })

package/core/__tests__/domain/agent-loader.test.js

@@ -0,0 +1,179 @@
+/**
+ * Tests for AgentLoader
+ * Verifies that agents are loaded correctly from project files
+ */
+
+const fs = require('fs').promises
+const path = require('path')
+const os = require('os')
+const { describe, it, expect, beforeEach, afterEach } = require('vitest')
+const AgentLoader = require('../../domain/agent-loader')
+
+describe('AgentLoader', () => {
+  let testProjectId
+  let testAgentsDir
+  let loader
+
+  beforeEach(async () => {
+    // Create unique test project ID
+    testProjectId = `test-${Date.now()}`
+    testAgentsDir = path.join(os.homedir(), '.prjct-cli', 'projects', testProjectId, 'agents')
+    await fs.mkdir(testAgentsDir, { recursive: true })
+    loader = new AgentLoader(testProjectId)
+  })
+
+  afterEach(async () => {
+    // Cleanup: Remove test agents directory
+    try {
+      await fs.rm(testAgentsDir, { recursive: true, force: true })
+    } catch (error) {
+      // Ignore cleanup errors
+    }
+  })
+
+  describe('loadAgent', () => {
+    it('should load an existing agent from file', async () => {
+      // Create test agent file
+      const agentName = 'frontend-specialist'
+      const agentContent = `# AGENT: FRONTEND-SPECIALIST
+Role: Frontend Development Specialist
+
+## META-INSTRUCTION
+You are a frontend specialist.
+
+## DOMAIN AUTHORITY
+You are the owner of the frontend domain.
+`
+
+      const agentPath = path.join(testAgentsDir, `${agentName}.md`)
+      await fs.writeFile(agentPath, agentContent, 'utf-8')
+
+      // Load agent
+      const agent = await loader.loadAgent(agentName)
+
+      // Verify
+      expect(agent).not.toBeNull()
+      expect(agent.name).toBe(agentName)
+      expect(agent.content).toBe(agentContent)
+      expect(agent.role).toBe('Frontend Development Specialist')
+      expect(agent.domain).toBe('frontend')
+    })
+
+    it('should return null for non-existent agent', async () => {
+      const agent = await loader.loadAgent('non-existent-agent')
+      expect(agent).toBeNull()
+    })
+
+    it('should cache loaded agents', async () => {
+      // Create test agent
+      const agentName = 'backend-specialist'
+      const agentPath = path.join(testAgentsDir, `${agentName}.md`)
+      await fs.writeFile(agentPath, '# AGENT: BACKEND-SPECIALIST\nRole: Backend Specialist', 'utf-8')
+
+      // Load twice
+      const agent1 = await loader.loadAgent(agentName)
+      const agent2 = await loader.loadAgent(agentName)
+
+      // Should be same object (cached)
+      expect(agent1).toBe(agent2)
+    })
+
+    it('should extract skills from agent content', async () => {
+      const agentName = 'react-specialist'
+      const agentContent = `# AGENT: REACT-SPECIALIST
+Role: React Development Specialist
+
+This agent specializes in React, TypeScript, and Next.js.
+`
+
+      const agentPath = path.join(testAgentsDir, `${agentName}.md`)
+      await fs.writeFile(agentPath, agentContent, 'utf-8')
+
+      const agent = await loader.loadAgent(agentName)
+
+      expect(agent.skills).toContain('React')
+      expect(agent.skills).toContain('TypeScript')
+      expect(agent.skills).toContain('Next.js')
+    })
+  })
+
+  describe('loadAllAgents', () => {
+    it('should load all agents in the directory', async () => {
+      // Create multiple agent files
+      const agents = [
+        { name: 'frontend-specialist', content: '# AGENT: FRONTEND-SPECIALIST\nRole: Frontend' },
+        { name: 'backend-specialist', content: '# AGENT: BACKEND-SPECIALIST\nRole: Backend' },
+        { name: 'qa-specialist', content: '# AGENT: QA-SPECIALIST\nRole: QA' }
+      ]
+
+      for (const agent of agents) {
+        const agentPath = path.join(testAgentsDir, `${agent.name}.md`)
+        await fs.writeFile(agentPath, agent.content, 'utf-8')
+      }
+
+      // Load all
+      const loadedAgents = await loader.loadAllAgents()
+
+      expect(loadedAgents).toHaveLength(3)
+      expect(loadedAgents.map(a => a.name)).toContain('frontend-specialist')
+      expect(loadedAgents.map(a => a.name)).toContain('backend-specialist')
+      expect(loadedAgents.map(a => a.name)).toContain('qa-specialist')
+    })
+
+    it('should return empty array if no agents exist', async () => {
+      const agents = await loader.loadAllAgents()
+      expect(agents).toEqual([])
+    })
+
+    it('should ignore non-markdown files', async () => {
+      // Create agent file and non-agent file
+      const agentPath = path.join(testAgentsDir, 'frontend-specialist.md')
+      await fs.writeFile(agentPath, '# AGENT', 'utf-8')
+
+      const otherFile = path.join(testAgentsDir, 'config.json')
+      await fs.writeFile(otherFile, '{}', 'utf-8')
+
+      const agents = await loader.loadAllAgents()
+
+      expect(agents).toHaveLength(1)
+      expect(agents[0].name).toBe('frontend-specialist')
+    })
+  })
+
+  describe('agentExists', () => {
+    it('should return true for existing agent', async () => {
+      const agentName = 'test-agent'
+      const agentPath = path.join(testAgentsDir, `${agentName}.md`)
+      await fs.writeFile(agentPath, '# AGENT', 'utf-8')
+
+      const exists = await loader.agentExists(agentName)
+      expect(exists).toBe(true)
+    })
+
+    it('should return false for non-existent agent', async () => {
+      const exists = await loader.agentExists('non-existent')
+      expect(exists).toBe(false)
+    })
+  })
+
+  describe('clearCache', () => {
+    it('should clear the agent cache', async () => {
+      const agentName = 'test-agent'
+      const agentPath = path.join(testAgentsDir, `${agentName}.md`)
+      await fs.writeFile(agentPath, '# AGENT', 'utf-8')
+
+      // Load and cache
+      const agent1 = await loader.loadAgent(agentName)
+      expect(agent1).not.toBeNull()
+
+      // Clear cache
+      loader.clearCache()
+
+      // Load again - should still work but be new object
+      const agent2 = await loader.loadAgent(agentName)
+      expect(agent2).not.toBeNull()
+      // Note: In real usage, they might be same due to file system, but cache is cleared
+    })
+  })
+})
+

package/core/__tests__/domain/analyzer.test.js

@@ -0,0 +1,324 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { createRequire } from 'module'
+import path from 'path'
+import fs from 'fs/promises'
+import os from 'os'
+
+const require = createRequire(import.meta.url)
+
+describe('Codebase Analyzer', () => {
+  let analyzer
+  let testProjectPath
+  let tempDir
+
+  beforeEach(async () => {
+    analyzer = require('../../domain/analyzer.js')
+
+    // Create temporary test directory
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'prjct-test-'))
+    testProjectPath = tempDir
+
+    analyzer.init(testProjectPath)
+  })
+
+  afterEach(async () => {
+    if (tempDir) {
+      try {
+        await fs.rm(tempDir, { recursive: true, force: true })
+      } catch (error) {
+        // Ignore cleanup errors
+      }
+    }
+  })
+
+  describe('init()', () => {
+    it('should initialize with project path', () => {
+      analyzer.init('/test/path')
+      expect(analyzer.projectPath).toBe('/test/path')
+    })
+
+    it('should use current directory if no path provided', () => {
+      analyzer.init()
+      expect(analyzer.projectPath).toBeDefined()
+    })
+  })
+
+  describe('readPackageJson()', () => {
+    it('should read package.json when it exists', async () => {
+      const packageJson = {
+        name: 'test-project',
+        version: '1.0.0',
+        dependencies: { express: '^4.18.0' }
+      }
+      await fs.writeFile(
+        path.join(testProjectPath, 'package.json'),
+        JSON.stringify(packageJson, null, 2)
+      )
+
+      const result = await analyzer.readPackageJson()
+
+      expect(result).toBeDefined()
+      expect(result.name).toBe('test-project')
+      expect(result.dependencies.express).toBeDefined()
+    })
+
+    it('should return null when package.json does not exist', async () => {
+      const result = await analyzer.readPackageJson()
+
+      expect(result).toBeNull()
+    })
+
+    it('should return null for invalid JSON', async () => {
+      await fs.writeFile(path.join(testProjectPath, 'package.json'), 'invalid json{')
+
+      const result = await analyzer.readPackageJson()
+
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('readCargoToml()', () => {
+    it('should read Cargo.toml when it exists', async () => {
+      const cargoContent = '[package]\nname = "test-project"\nversion = "0.1.0"'
+      await fs.writeFile(path.join(testProjectPath, 'Cargo.toml'), cargoContent)
+
+      const result = await analyzer.readCargoToml()
+
+      expect(result).toBeDefined()
+      expect(result).toContain('test-project')
+    })
+
+    it('should return null when Cargo.toml does not exist', async () => {
+      const result = await analyzer.readCargoToml()
+
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('readRequirements()', () => {
+    it('should read requirements.txt when it exists', async () => {
+      const requirements = 'flask==2.0.0\nrequests==2.28.0'
+      await fs.writeFile(path.join(testProjectPath, 'requirements.txt'), requirements)
+
+      const result = await analyzer.readRequirements()
+
+      expect(result).toBeDefined()
+      expect(result).toContain('flask')
+    })
+
+    it('should return null when requirements.txt does not exist', async () => {
+      const result = await analyzer.readRequirements()
+
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('readGoMod()', () => {
+    it('should read go.mod when it exists', async () => {
+      const goMod = 'module test-project\n\ngo 1.19'
+      await fs.writeFile(path.join(testProjectPath, 'go.mod'), goMod)
+
+      const result = await analyzer.readGoMod()
+
+      expect(result).toBeDefined()
+      expect(result).toContain('test-project')
+    })
+
+    it('should return null when go.mod does not exist', async () => {
+      const result = await analyzer.readGoMod()
+
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('listDirectories()', () => {
+    it('should list directories in project root', async () => {
+      await fs.mkdir(path.join(testProjectPath, 'src'), { recursive: true })
+      await fs.mkdir(path.join(testProjectPath, 'tests'), { recursive: true })
+      await fs.writeFile(path.join(testProjectPath, 'file.txt'), 'content')
+
+      const directories = await analyzer.listDirectories()
+
+      expect(directories).toContain('src')
+      expect(directories).toContain('tests')
+      expect(directories).not.toContain('file.txt')
+    })
+
+    it('should exclude hidden directories', async () => {
+      await fs.mkdir(path.join(testProjectPath, '.git'), { recursive: true })
+      await fs.mkdir(path.join(testProjectPath, 'src'), { recursive: true })
+
+      const directories = await analyzer.listDirectories()
+
+      expect(directories).not.toContain('.git')
+      expect(directories).toContain('src')
+    })
+
+    it('should exclude node_modules', async () => {
+      await fs.mkdir(path.join(testProjectPath, 'node_modules'), { recursive: true })
+      await fs.mkdir(path.join(testProjectPath, 'src'), { recursive: true })
+
+      const directories = await analyzer.listDirectories()
+
+      expect(directories).not.toContain('node_modules')
+      expect(directories).toContain('src')
+    })
+
+    it('should return empty array for non-existent directory', async () => {
+      analyzer.init('/nonexistent/path')
+
+      const directories = await analyzer.listDirectories()
+
+      expect(directories).toEqual([])
+    })
+  })
+
+  describe('fileExists()', () => {
+    it('should return true for existing file', async () => {
+      await fs.writeFile(path.join(testProjectPath, 'test.txt'), 'content')
+
+      const exists = await analyzer.fileExists('test.txt')
+
+      expect(exists).toBe(true)
+    })
+
+    it('should return false for non-existent file', async () => {
+      const exists = await analyzer.fileExists('nonexistent.txt')
+
+      expect(exists).toBe(false)
+    })
+  })
+
+  describe('readFile()', () => {
+    it('should read file content', async () => {
+      const content = 'file content here'
+      await fs.writeFile(path.join(testProjectPath, 'test.txt'), content)
+
+      const result = await analyzer.readFile('test.txt')
+
+      expect(result).toBe(content)
+    })
+
+    it('should return null for non-existent file', async () => {
+      const result = await analyzer.readFile('nonexistent.txt')
+
+      expect(result).toBeNull()
+    })
+
+    it('should read nested files', async () => {
+      await fs.mkdir(path.join(testProjectPath, 'src'), { recursive: true })
+      await fs.writeFile(path.join(testProjectPath, 'src', 'app.js'), 'console.log("test")')
+
+      const result = await analyzer.readFile('src/app.js')
+
+      expect(result).toBe('console.log("test")')
+    })
+  })
+
+  describe('getGitLog()', () => {
+    it('should return git log when git repo exists', async () => {
+      // Initialize git repo for testing
+      try {
+        const { exec } = require('child_process')
+        const { promisify } = require('util')
+        const execAsync = promisify(exec)
+
+        await execAsync('git init', { cwd: testProjectPath })
+        await execAsync('git config user.email "test@test.com"', { cwd: testProjectPath })
+        await execAsync('git config user.name "Test User"', { cwd: testProjectPath })
+        await fs.writeFile(path.join(testProjectPath, 'test.txt'), 'content')
+        await execAsync('git add test.txt', { cwd: testProjectPath })
+        await execAsync('git commit -m "Initial commit"', { cwd: testProjectPath })
+
+        const log = await analyzer.getGitLog(10)
+
+        expect(typeof log).toBe('string')
+      } catch (error) {
+        // Git might not be available, skip test
+        expect(true).toBe(true)
+      }
+    })
+
+    it('should return empty string when git repo does not exist', async () => {
+      const log = await analyzer.getGitLog()
+
+      expect(log).toBe('')
+    })
+  })
+
+  describe('getGitStats()', () => {
+    it('should return git statistics when git repo exists', async () => {
+      try {
+        const { exec } = require('child_process')
+        const { promisify } = require('util')
+        const execAsync = promisify(exec)
+
+        await execAsync('git init', { cwd: testProjectPath })
+        await execAsync('git config user.email "test@test.com"', { cwd: testProjectPath })
+        await execAsync('git config user.name "Test User"', { cwd: testProjectPath })
+        await fs.writeFile(path.join(testProjectPath, 'test.txt'), 'content')
+        await execAsync('git add test.txt', { cwd: testProjectPath })
+        await execAsync('git commit -m "Initial commit"', { cwd: testProjectPath })
+
+        const stats = await analyzer.getGitStats()
+
+        expect(stats).toBeDefined()
+        expect(stats.totalCommits).toBeGreaterThanOrEqual(0)
+        expect(stats.contributors).toBeGreaterThanOrEqual(0)
+      } catch (error) {
+        // Git might not be available, skip test
+        expect(true).toBe(true)
+      }
+    })
+
+    it('should return default stats when git repo does not exist', async () => {
+      const stats = await analyzer.getGitStats()
+
+      expect(stats).toBeDefined()
+      expect(stats.totalCommits).toBe(0)
+      expect(stats.contributors).toBe(0)
+      expect(stats.age).toBe('unknown')
+    })
+  })
+
+  describe('countFiles()', () => {
+    it('should count files in project', async () => {
+      await fs.writeFile(path.join(testProjectPath, 'file1.txt'), 'content')
+      await fs.writeFile(path.join(testProjectPath, 'file2.txt'), 'content')
+      await fs.mkdir(path.join(testProjectPath, 'src'), { recursive: true })
+      await fs.writeFile(path.join(testProjectPath, 'src', 'app.js'), 'content')
+
+      const count = await analyzer.countFiles()
+
+      expect(count).toBeGreaterThan(0)
+    })
+
+    it('should return 0 for empty directory', async () => {
+      const count = await analyzer.countFiles()
+
+      // May have some files, so just check it's a number
+      expect(typeof count).toBe('number')
+    })
+  })
+
+  describe('findFiles()', () => {
+    it('should find files matching pattern', async () => {
+      await fs.writeFile(path.join(testProjectPath, 'app.js'), 'content')
+      await fs.writeFile(path.join(testProjectPath, 'test.js'), 'content')
+      await fs.mkdir(path.join(testProjectPath, 'src'), { recursive: true })
+      await fs.writeFile(path.join(testProjectPath, 'src', 'app.js'), 'content')
+
+      const files = await analyzer.findFiles('app.js')
+
+      expect(files.length).toBeGreaterThan(0)
+      expect(files.some(f => f.includes('app.js'))).toBe(true)
+    })
+
+    it('should return empty array when no files match', async () => {
+      const files = await analyzer.findFiles('nonexistent-pattern-xyz')
+
+      expect(files).toEqual([])
+    })
+  })
+})
+