prjct-cli 0.10.0 → 0.10.2

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

@@ -1,289 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import AgentGenerator from '../../domain/agent-generator.js'
-import fs from 'fs/promises'
-import os from 'os'
-import path from 'path'
-
-describe('Agent Generator', () => {
-  const testProjectId = 'test-agent-gen-' + Date.now()
-  const agentsDir = path.join(os.homedir(), '.prjct-cli', 'projects', testProjectId, 'agents')
-  const generator = new AgentGenerator(testProjectId)
-
-  afterEach(async () => {
-    // Cleanup test files
-    try {
-      await fs.rm(agentsDir, { recursive: true, force: true })
-    } catch (error) {
-      // Ignore cleanup errors
-    }
-  })
-
-  describe('Constructor', () => {
-    it('should create generator with project ID', () => {
-      expect(generator.projectId).toBe(testProjectId)
-      expect(generator.outputDir).toContain(testProjectId)
-    })
-
-    it('should use fallback directory without project ID', () => {
-      const fallbackGenerator = new AgentGenerator()
-      expect(fallbackGenerator.outputDir).toContain('.prjct-cli/agents')
-      expect(fallbackGenerator.outputDir).not.toContain('projects')
-    })
-
-    it('should construct correct output path', () => {
-      expect(generator.outputDir).toBe(agentsDir)
-    })
-  })
-
-  describe('generateDynamicAgent()', () => {
-    it('should generate agent file', async () => {
-      await generator.generateDynamicAgent('test-agent', {
-        role: 'Test Agent Role',
-        expertise: 'Test Technologies',
-        responsibilities: 'Test Responsibilities',
-      })
-
-      const agentFile = path.join(agentsDir, 'test-agent.md')
-      const exists = await fs
-        .access(agentFile)
-        .then(() => true)
-        .catch(() => false)
-
-      expect(exists).toBe(true)
-    })
-
-    it('should create agent with correct content', async () => {
-      await generator.generateDynamicAgent('backend-agent', {
-        role: 'Backend Developer',
-        expertise: 'Node.js, Express, PostgreSQL',
-        responsibilities: 'API development and database management',
-      })
-
-      const content = await fs.readFile(path.join(agentsDir, 'backend-agent.md'), 'utf-8')
-
-      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 () => {
-      await generator.generateDynamicAgent('context-agent', {
-        role: 'Agent with Context',
-        expertise: 'Testing',
-        responsibilities: 'Test things',
-        projectContext: {
-          framework: 'React',
-          version: '18.0',
-        },
-      })
-
-      const content = await fs.readFile(path.join(agentsDir, 'context-agent.md'), 'utf-8')
-
-      expect(content).toContain('## PROJECT CONTEXT')
-      expect(content).toContain('framework')
-      expect(content).toContain('React')
-      expect(content).toContain('version')
-      expect(content).toContain('18.0')
-    })
-
-    it('should handle missing optional fields', async () => {
-      await generator.generateDynamicAgent('minimal-agent', {
-        role: 'Minimal Role',
-      })
-
-      const content = await fs.readFile(path.join(agentsDir, 'minimal-agent.md'), 'utf-8')
-
-      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 () => {
-      const newProjectId = 'new-project-' + Date.now()
-      const newGenerator = new AgentGenerator(newProjectId)
-      const newAgentsDir = path.join(os.homedir(), '.prjct-cli', 'projects', newProjectId, 'agents')
-
-      await newGenerator.generateDynamicAgent('auto-create', {
-        role: 'Auto Created Agent',
-      })
-
-      const exists = await fs
-        .access(newAgentsDir)
-        .then(() => true)
-        .catch(() => false)
-
-      expect(exists).toBe(true)
-
-      // Cleanup
-      await fs.rm(path.join(os.homedir(), '.prjct-cli', 'projects', newProjectId), {
-        recursive: true,
-        force: true,
-      })
-    })
-
-    it('should create multiple agents', async () => {
-      await generator.generateDynamicAgent('agent-1', { role: 'Agent One' })
-      await generator.generateDynamicAgent('agent-2', { role: 'Agent Two' })
-      await generator.generateDynamicAgent('agent-3', { role: 'Agent Three' })
-
-      const agents = await generator.listAgents()
-
-      expect(agents).toHaveLength(3)
-      expect(agents).toContain('agent-1')
-      expect(agents).toContain('agent-2')
-      expect(agents).toContain('agent-3')
-    })
-
-    it('should use agent name as fallback for role', async () => {
-      await generator.generateDynamicAgent('fallback-agent', {})
-
-      const content = await fs.readFile(path.join(agentsDir, 'fallback-agent.md'), 'utf-8')
-
-      expect(content).toContain('# AGENT: FALLBACK-AGENT')
-    })
-  })
-
-  describe('cleanupObsoleteAgents()', () => {
-    beforeEach(async () => {
-      // Create some test agents
-      await generator.generateDynamicAgent('agent-1', { role: 'Agent 1' })
-      await generator.generateDynamicAgent('agent-2', { role: 'Agent 2' })
-      await generator.generateDynamicAgent('agent-3', { role: 'Agent 3' })
-    })
-
-    it('should remove obsolete agents', async () => {
-      const removed = await generator.cleanupObsoleteAgents(['agent-1', 'agent-2'])
-
-      expect(removed).toContain('agent-3')
-      expect(removed).toHaveLength(1)
-    })
-
-    it('should keep required agents', async () => {
-      await generator.cleanupObsoleteAgents(['agent-1', 'agent-2'])
-
-      const agents = await generator.listAgents()
-
-      expect(agents).toContain('agent-1')
-      expect(agents).toContain('agent-2')
-      expect(agents).not.toContain('agent-3')
-    })
-
-    it('should remove multiple obsolete agents', async () => {
-      await generator.generateDynamicAgent('agent-4', { role: 'Agent 4' })
-
-      const removed = await generator.cleanupObsoleteAgents(['agent-1'])
-
-      expect(removed).toHaveLength(3)
-      expect(removed).toContain('agent-2')
-      expect(removed).toContain('agent-3')
-      expect(removed).toContain('agent-4')
-    })
-
-    it('should return empty array if all agents are required', async () => {
-      const removed = await generator.cleanupObsoleteAgents(['agent-1', 'agent-2', 'agent-3'])
-
-      expect(removed).toEqual([])
-    })
-
-    it('should handle non-existent directory gracefully', async () => {
-      const emptyGenerator = new AgentGenerator('empty-' + Date.now())
-
-      const removed = await emptyGenerator.cleanupObsoleteAgents(['agent-1'])
-
-      expect(Array.isArray(removed)).toBe(true)
-    })
-  })
-
-  describe('listAgents()', () => {
-    it('should list all agents', async () => {
-      await generator.generateDynamicAgent('frontend', { role: 'Frontend' })
-      await generator.generateDynamicAgent('backend', { role: 'Backend' })
-
-      const agents = await generator.listAgents()
-
-      expect(agents).toHaveLength(2)
-      expect(agents).toContain('frontend')
-      expect(agents).toContain('backend')
-    })
-
-    it('should return empty array for no agents', async () => {
-      const agents = await generator.listAgents()
-
-      expect(agents).toEqual([])
-    })
-
-    it('should ignore non-.md files', async () => {
-      await generator.generateDynamicAgent('valid-agent', { role: 'Valid' })
-      await fs.writeFile(path.join(agentsDir, 'not-agent.txt'), 'text file')
-      await fs.writeFile(path.join(agentsDir, 'config.json'), '{}')
-
-      const agents = await generator.listAgents()
-
-      expect(agents).toHaveLength(1)
-      expect(agents).toContain('valid-agent')
-    })
-
-    it('should ignore hidden files', async () => {
-      await generator.generateDynamicAgent('visible', { role: 'Visible' })
-      await fs.writeFile(path.join(agentsDir, '.hidden.md'), 'hidden')
-
-      const agents = await generator.listAgents()
-
-      expect(agents).toHaveLength(1)
-      expect(agents).toContain('visible')
-    })
-  })
-
-  describe('Integration', () => {
-    it('should create, list, and cleanup agents', async () => {
-      // Create agents
-      await generator.generateDynamicAgent('keep-me', { role: 'Keep' })
-      await generator.generateDynamicAgent('remove-me', { role: 'Remove' })
-
-      // Verify they exist
-      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
-      const finalAgents = await generator.listAgents()
-      expect(finalAgents).toHaveLength(1)
-      expect(finalAgents).toContain('keep-me')
-    })
-
-    it('should handle agent file content correctly', async () => {
-      await generator.generateDynamicAgent('full-agent', {
-        role: 'Full Stack Developer',
-        expertise: 'React, Node.js, PostgreSQL, Docker',
-        responsibilities: 'Build and deploy full stack applications',
-        projectContext: {
-          stack: 'MERN',
-          deployment: 'AWS',
-        },
-      })
-
-      const content = await fs.readFile(path.join(agentsDir, 'full-agent.md'), 'utf-8')
-
-      // Should have all sections
-      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

@@ -1,179 +0,0 @@
-/**
- * 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
-    })
-  })
-})
-