prjct-cli 0.9.2 → 0.10.2

package/core/__tests__/agentic/template-loader.test.js

@@ -1,164 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest'
-import templateLoader from '../../agentic/template-loader.js'
-
-describe('Template Loader', () => {
-  beforeEach(() => {
-    templateLoader.clearCache()
-  })
-
-  describe('load()', () => {
-    it('should load a template successfully', async () => {
-      const template = await templateLoader.load('now')
-
-      expect(template).toBeDefined()
-      expect(template).toHaveProperty('content')
-      expect(template).toHaveProperty('frontmatter')
-    })
-
-    it('should load multiple templates', async () => {
-      const now = await templateLoader.load('now')
-      const done = await templateLoader.load('done')
-      const next = await templateLoader.load('next')
-
-      expect(now).toBeDefined()
-      expect(done).toBeDefined()
-      expect(next).toBeDefined()
-    })
-
-    it('should throw error for non-existent template', async () => {
-      await expect(templateLoader.load('nonexistent')).rejects.toThrow('Template not found: nonexistent.md')
-    })
-
-    it('should cache templates', async () => {
-      const first = await templateLoader.load('now')
-      const second = await templateLoader.load('now')
-
-      // Should return the same cached object
-      expect(first).toBe(second)
-    })
-  })
-
-  describe('parseFrontmatter()', () => {
-    it('should parse frontmatter correctly', () => {
-      const content = `---
-allowed-tools: [Read, Write, Bash]
-category: core
----
-# Template Content
-
-This is the main content.`
-
-      const parsed = templateLoader.parseFrontmatter(content)
-
-      expect(parsed.frontmatter).toHaveProperty('allowed-tools')
-      expect(parsed.frontmatter['allowed-tools']).toEqual(['Read', 'Write', 'Bash'])
-      expect(parsed.frontmatter.category).toBe('core')
-      expect(parsed.content).toContain('# Template Content')
-    })
-
-    it('should handle templates without frontmatter', () => {
-      const content = `# Simple Template
-
-Just content, no frontmatter.`
-
-      const parsed = templateLoader.parseFrontmatter(content)
-
-      expect(parsed.frontmatter).toEqual({})
-      expect(parsed.content).toContain('# Simple Template')
-    })
-
-    it('should parse string values', () => {
-      const content = `---
-title: Test Command
-description: A test command
----
-Content`
-
-      const parsed = templateLoader.parseFrontmatter(content)
-
-      expect(parsed.frontmatter.title).toBe('Test Command')
-      expect(parsed.frontmatter.description).toBe('A test command')
-    })
-
-    it('should handle quoted strings', () => {
-      const content = `---
-title: "Quoted Title"
-description: 'Single Quoted'
----
-Content`
-
-      const parsed = templateLoader.parseFrontmatter(content)
-
-      expect(parsed.frontmatter.title).toBe('Quoted Title')
-      expect(parsed.frontmatter.description).toBe('Single Quoted')
-    })
-
-    it('should parse array values', () => {
-      const content = `---
-tools: [Read, Write, Exec]
-tags: [core, important]
----
-Content`
-
-      const parsed = templateLoader.parseFrontmatter(content)
-
-      expect(Array.isArray(parsed.frontmatter.tools)).toBe(true)
-      expect(parsed.frontmatter.tools).toEqual(['Read', 'Write', 'Exec'])
-      expect(parsed.frontmatter.tags).toEqual(['core', 'important'])
-    })
-  })
-
-  describe('getAllowedTools()', () => {
-    it('should return allowed tools from template', async () => {
-      const tools = await templateLoader.getAllowedTools('now')
-
-      expect(Array.isArray(tools)).toBe(true)
-    })
-
-    it('should return empty array if no allowed-tools defined', async () => {
-      // Create a mock template without allowed-tools
-      const content = `# Simple Template
-No tools defined`
-
-      const parsed = templateLoader.parseFrontmatter(content)
-      expect(parsed.frontmatter['allowed-tools'] || []).toEqual([])
-    })
-  })
-
-  describe('clearCache()', () => {
-    it('should clear the cache', async () => {
-      // Load and cache
-      await templateLoader.load('now')
-
-      // Clear cache
-      templateLoader.clearCache()
-
-      // Load again - should read from file, not cache
-      const template = await templateLoader.load('now')
-      expect(template).toBeDefined()
-    })
-  })
-
-  describe('Real Templates', () => {
-    it('should load "now" template', async () => {
-      const template = await templateLoader.load('now')
-
-      expect(template.content).toBeTruthy()
-      expect(template.content.length).toBeGreaterThan(0)
-    })
-
-    it('should load "done" template', async () => {
-      const template = await templateLoader.load('done')
-
-      expect(template.content).toBeTruthy()
-      expect(template.content.length).toBeGreaterThan(0)
-    })
-
-    it('should load "ship" template', async () => {
-      const template = await templateLoader.load('ship')
-
-      expect(template.content).toBeTruthy()
-      expect(template.content.length).toBeGreaterThan(0)
-    })
-  })
-})

package/core/__tests__/agentic/tool-registry.test.js

@@ -1,243 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import toolRegistry from '../../agentic/tool-registry.js'
-import fs from 'fs/promises'
-import path from 'path'
-import os from 'os'
-
-describe('Tool Registry', () => {
-  const testDir = path.join(os.tmpdir(), 'prjct-test-' + Date.now())
-  const testFile = path.join(testDir, 'test.txt')
-
-  beforeEach(async () => {
-    await fs.mkdir(testDir, { recursive: true })
-  })
-
-  afterEach(async () => {
-    try {
-      await fs.rm(testDir, { recursive: true, force: true })
-    } catch (error) {
-      // Ignore cleanup errors
-    }
-  })
-
-  describe('get()', () => {
-    it('should get Read tool', () => {
-      const tool = toolRegistry.get('Read')
-
-      expect(tool).toBeDefined()
-      expect(typeof tool).toBe('function')
-    })
-
-    it('should get Write tool', () => {
-      const tool = toolRegistry.get('Write')
-
-      expect(tool).toBeDefined()
-      expect(typeof tool).toBe('function')
-    })
-
-    it('should get Bash tool', () => {
-      const tool = toolRegistry.get('Bash')
-
-      expect(tool).toBeDefined()
-      expect(typeof tool).toBe('function')
-    })
-
-    it('should get Exec tool (alias for Bash)', () => {
-      const tool = toolRegistry.get('Exec')
-
-      expect(tool).toBeDefined()
-      expect(typeof tool).toBe('function')
-    })
-
-    it('should throw error for unknown tool', () => {
-      expect(() => toolRegistry.get('UnknownTool')).toThrow('Unknown tool: UnknownTool')
-    })
-  })
-
-  describe('isAllowed()', () => {
-    it('should return true for allowed tool', () => {
-      const allowed = toolRegistry.isAllowed('Read', ['Read', 'Write', 'Bash'])
-
-      expect(allowed).toBe(true)
-    })
-
-    it('should return false for disallowed tool', () => {
-      const allowed = toolRegistry.isAllowed('Exec', ['Read', 'Write'])
-
-      expect(allowed).toBe(false)
-    })
-
-    it('should handle empty allowed list', () => {
-      const allowed = toolRegistry.isAllowed('Read', [])
-
-      expect(allowed).toBe(false)
-    })
-  })
-
-  describe('read()', () => {
-    it('should read file content', async () => {
-      const content = 'Test content for reading'
-      await fs.writeFile(testFile, content)
-
-      const result = await toolRegistry.read(testFile)
-
-      expect(result).toBe(content)
-    })
-
-    it('should return null for non-existent file', async () => {
-      const result = await toolRegistry.read('/nonexistent/file.txt')
-
-      expect(result).toBeNull()
-    })
-
-    it('should read UTF-8 encoded content', async () => {
-      const content = 'UTF-8: ñ é ü 中文 日本語'
-      await fs.writeFile(testFile, content)
-
-      const result = await toolRegistry.read(testFile)
-
-      expect(result).toBe(content)
-    })
-  })
-
-  describe('write()', () => {
-    it('should write file content', async () => {
-      const content = 'Test content for writing'
-
-      await toolRegistry.write(testFile, content)
-
-      const result = await fs.readFile(testFile, 'utf-8')
-      expect(result).toBe(content)
-    })
-
-    it('should create directory if not exists', async () => {
-      const nestedFile = path.join(testDir, 'nested', 'dir', 'file.txt')
-      const content = 'Nested content'
-
-      await toolRegistry.write(nestedFile, content)
-
-      const result = await fs.readFile(nestedFile, 'utf-8')
-      expect(result).toBe(content)
-    })
-
-    it('should overwrite existing file', async () => {
-      await toolRegistry.write(testFile, 'First content')
-      await toolRegistry.write(testFile, 'Second content')
-
-      const result = await fs.readFile(testFile, 'utf-8')
-      expect(result).toBe('Second content')
-    })
-  })
-
-  describe('bash()', () => {
-    it('should execute simple command', async () => {
-      const result = await toolRegistry.bash('echo "hello"')
-
-      expect(result.stdout).toContain('hello')
-      expect(result.stderr).toBe('')
-    })
-
-    it('should return stdout and stderr', async () => {
-      const result = await toolRegistry.bash('echo "output"')
-
-      expect(result).toHaveProperty('stdout')
-      expect(result).toHaveProperty('stderr')
-    })
-
-    it('should handle command errors', async () => {
-      const result = await toolRegistry.bash('invalid-command-xyz-123')
-
-      expect(result.error).toBe(true)
-      expect(result.stderr).toBeTruthy()
-    })
-
-    it('should execute pwd command', async () => {
-      const result = await toolRegistry.bash('pwd')
-
-      expect(result.stdout).toBeTruthy()
-      expect(result.stderr).toBe('')
-    })
-  })
-
-  describe('exists()', () => {
-    it('should return true for existing file', async () => {
-      await fs.writeFile(testFile, 'content')
-
-      const exists = await toolRegistry.exists(testFile)
-
-      expect(exists).toBe(true)
-    })
-
-    it('should return false for non-existent file', async () => {
-      const exists = await toolRegistry.exists('/nonexistent/file.txt')
-
-      expect(exists).toBe(false)
-    })
-
-    it('should work with directories', async () => {
-      const exists = await toolRegistry.exists(testDir)
-
-      expect(exists).toBe(true)
-    })
-  })
-
-  describe('list()', () => {
-    it('should list directory contents', async () => {
-      await fs.writeFile(path.join(testDir, 'file1.txt'), 'content1')
-      await fs.writeFile(path.join(testDir, 'file2.txt'), 'content2')
-
-      const files = await toolRegistry.list(testDir)
-
-      expect(Array.isArray(files)).toBe(true)
-      expect(files.length).toBeGreaterThanOrEqual(2)
-      expect(files).toContain('file1.txt')
-      expect(files).toContain('file2.txt')
-    })
-
-    it('should return empty array for non-existent directory', async () => {
-      const files = await toolRegistry.list('/nonexistent/directory')
-
-      expect(files).toEqual([])
-    })
-
-    it('should list empty directory', async () => {
-      const emptyDir = path.join(testDir, 'empty')
-      await fs.mkdir(emptyDir)
-
-      const files = await toolRegistry.list(emptyDir)
-
-      expect(Array.isArray(files)).toBe(true)
-      expect(files.length).toBe(0)
-    })
-  })
-
-  describe('Integration', () => {
-    it('should write and then read file', async () => {
-      const content = 'Integration test content'
-
-      await toolRegistry.write(testFile, content)
-      const result = await toolRegistry.read(testFile)
-
-      expect(result).toBe(content)
-    })
-
-    it('should check existence, write, and list', async () => {
-      const newFile = path.join(testDir, 'integration.txt')
-
-      // Check doesn't exist
-      const existsBefore = await toolRegistry.exists(newFile)
-      expect(existsBefore).toBe(false)
-
-      // Write
-      await toolRegistry.write(newFile, 'content')
-
-      // Check exists
-      const existsAfter = await toolRegistry.exists(newFile)
-      expect(existsAfter).toBe(true)
-
-      // List directory
-      const files = await toolRegistry.list(testDir)
-      expect(files).toContain('integration.txt')
-    })
-  })
-})

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

@@ -1,296 +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()
-  let generator
-  let agentsDir
-
-  beforeEach(() => {
-    generator = new AgentGenerator(testProjectId)
-    agentsDir = path.join(os.homedir(), '.prjct-cli', 'projects', testProjectId, 'agents')
-  })
-
-  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('# 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')
-    })
-
-    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('# Minimal Role')
-      expect(content).toContain('Technologies used in this project')
-      expect(content).toContain('Handle specific aspects of development')
-      expect(content).toContain('No additional context')
-    })
-
-    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('# 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
-      let agents = await generator.listAgents()
-      expect(agents).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')
-    })
-
-    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('# 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('MERN')
-      expect(content).toContain('AWS')
-    })
-  })
-})