prjct-cli 0.7.1 → 0.7.3

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

@@ -0,0 +1,296 @@
+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')
+    })
+  })
+})

package/core/__tests__/setup.test.js

@@ -0,0 +1,15 @@
+import { describe, it, expect } from 'vitest'
+
+describe('Vitest Setup', () => {
+  it('should pass basic assertion', () => {
+    expect(true).toBe(true)
+  })
+
+  it('should handle numbers', () => {
+    expect(2 + 2).toBe(4)
+  })
+
+  it('should handle strings', () => {
+    expect('prjct-cli').toContain('prjct')
+  })
+})

package/core/__tests__/utils/date-helper.test.js

@@ -0,0 +1,169 @@
+import { describe, it, expect } from 'vitest'
+import * as dateHelper from '../../utils/date-helper.js'
+
+describe('Date Helper', () => {
+  describe('formatDate()', () => {
+    it('should format date to YYYY-MM-DD', () => {
+      const date = new Date(2025, 9, 4, 12, 0, 0) // October 4, 2025
+      const formatted = dateHelper.formatDate(date)
+
+      expect(formatted).toMatch(/^\d{4}-\d{2}-\d{2}$/)
+    })
+
+    it('should pad single digit month', () => {
+      const date = new Date(2025, 2, 15) // March 15, 2025
+      const formatted = dateHelper.formatDate(date)
+
+      expect(formatted).toContain('-03-')
+    })
+
+    it('should pad single digit day', () => {
+      const date = new Date(2025, 9, 5) // October 5, 2025
+      const formatted = dateHelper.formatDate(date)
+
+      expect(formatted).toContain('-05')
+    })
+
+    it('should handle edge case dates', () => {
+      const date = new Date(2025, 0, 1) // January 1, 2025
+      const formatted = dateHelper.formatDate(date)
+
+      expect(formatted).toBe('2025-01-01')
+    })
+
+    it('should handle end of year', () => {
+      const date = new Date(2025, 11, 31) // December 31, 2025
+      const formatted = dateHelper.formatDate(date)
+
+      expect(formatted).toBe('2025-12-31')
+    })
+  })
+
+  describe('formatMonth()', () => {
+    it('should format date to YYYY-MM', () => {
+      const date = new Date('2025-10-04')
+      const formatted = dateHelper.formatMonth(date)
+
+      expect(formatted).toMatch(/^\d{4}-\d{2}$/)
+      expect(formatted).toBe('2025-10')
+    })
+
+    it('should pad single digit month', () => {
+      const date = new Date('2025-03-15')
+      const formatted = dateHelper.formatMonth(date)
+
+      expect(formatted).toBe('2025-03')
+    })
+
+    it('should handle January', () => {
+      const date = new Date('2025-01-15')
+      const formatted = dateHelper.formatMonth(date)
+
+      expect(formatted).toBe('2025-01')
+    })
+
+    it('should handle December', () => {
+      const date = new Date('2025-12-25')
+      const formatted = dateHelper.formatMonth(date)
+
+      expect(formatted).toBe('2025-12')
+    })
+  })
+
+  describe('getTodayKey()', () => {
+    it('should return today in YYYY-MM-DD format', () => {
+      const today = dateHelper.getTodayKey()
+
+      expect(today).toMatch(/^\d{4}-\d{2}-\d{2}$/)
+    })
+
+    it('should match formatDate for current date', () => {
+      const today = dateHelper.getTodayKey()
+      const now = dateHelper.formatDate(new Date())
+
+      expect(today).toBe(now)
+    })
+  })
+
+  describe('getDateKey()', () => {
+    it('should return date key in YYYY-MM-DD format', () => {
+      const date = new Date(2025, 9, 4) // October 4, 2025
+      const key = dateHelper.getDateKey(date)
+
+      expect(key).toBe('2025-10-04')
+    })
+
+    it('should be alias for formatDate', () => {
+      const date = new Date(2025, 9, 4) // October 4, 2025
+
+      expect(dateHelper.getDateKey(date)).toBe(dateHelper.formatDate(date))
+    })
+  })
+
+  describe('getTimestamp()', () => {
+    it('should return ISO timestamp', () => {
+      const timestamp = dateHelper.getTimestamp()
+
+      expect(timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/)
+    })
+
+    it('should be valid date string', () => {
+      const timestamp = dateHelper.getTimestamp()
+      const date = new Date(timestamp)
+
+      expect(date.toString()).not.toBe('Invalid Date')
+    })
+  })
+
+  describe('calculateDuration()', () => {
+    it('should calculate duration in minutes', () => {
+      const start = new Date('2025-10-04T10:00:00Z')
+      const end = new Date('2025-10-04T10:30:00Z')
+      const duration = dateHelper.calculateDuration(start, end)
+
+      expect(duration).toContain('30m')
+    })
+
+    it('should calculate duration in hours and minutes', () => {
+      const start = new Date('2025-10-04T10:00:00Z')
+      const end = new Date('2025-10-04T12:30:00Z')
+      const duration = dateHelper.calculateDuration(start, end)
+
+      expect(duration).toContain('2h')
+      expect(duration).toContain('30m')
+    })
+
+    it('should handle exact hours', () => {
+      const start = new Date('2025-10-04T10:00:00Z')
+      const end = new Date('2025-10-04T13:00:00Z')
+      const duration = dateHelper.calculateDuration(start, end)
+
+      expect(duration).toContain('3h')
+    })
+
+    it('should handle less than 1 minute', () => {
+      const start = new Date('2025-10-04T10:00:00Z')
+      const end = new Date('2025-10-04T10:00:30Z')
+      const duration = dateHelper.calculateDuration(start, end)
+
+      expect(duration).toContain('30s')
+    })
+  })
+
+  describe('Edge Cases', () => {
+    it('should handle leap year', () => {
+      const date = new Date(2024, 1, 29) // February 29, 2024
+      const formatted = dateHelper.formatDate(date)
+
+      expect(formatted).toBe('2024-02-29')
+    })
+
+    it('should handle different years', () => {
+      const date2024 = new Date(2024, 9, 4) // October 4, 2024
+      const date2025 = new Date(2025, 9, 4) // October 4, 2025
+
+      expect(dateHelper.formatDate(date2024)).toBe('2024-10-04')
+      expect(dateHelper.formatDate(date2025)).toBe('2025-10-04')
+    })
+  })
+})