prjct-cli 0.7.2 → 0.8.0

package/core/__tests__/agentic/command-executor.test.js

@@ -0,0 +1,223 @@
+import { describe, it, expect } from 'vitest'
+import commandExecutor from '../../agentic/command-executor.js'
+
+describe('Command Executor', () => {
+  const testProjectPath = process.cwd()
+
+  describe('execute()', () => {
+    it('should execute command successfully', async () => {
+      const result = await commandExecutor.execute('now', {}, testProjectPath)
+
+      expect(result).toBeDefined()
+      expect(result.success).toBe(true)
+    })
+
+    it('should load template', async () => {
+      const result = await commandExecutor.execute('now', {}, testProjectPath)
+
+      expect(result.template).toBeDefined()
+      expect(result.template).toHaveProperty('content')
+      expect(result.template).toHaveProperty('frontmatter')
+    })
+
+    it('should build context', async () => {
+      const result = await commandExecutor.execute('now', {}, testProjectPath)
+
+      expect(result.context).toBeDefined()
+      expect(result.context).toHaveProperty('projectId')
+      expect(result.context).toHaveProperty('projectPath')
+      expect(result.context).toHaveProperty('paths')
+    })
+
+    it('should load state', async () => {
+      const result = await commandExecutor.execute('now', {}, testProjectPath)
+
+      expect(result.state).toBeDefined()
+      expect(typeof result.state).toBe('object')
+    })
+
+    it('should build prompt', async () => {
+      const result = await commandExecutor.execute('now', {}, testProjectPath)
+
+      expect(result.prompt).toBeDefined()
+      expect(typeof result.prompt).toBe('string')
+      expect(result.prompt.length).toBeGreaterThan(0)
+    })
+
+    it('should pass parameters to context', async () => {
+      const params = { taskName: 'Test Task', feature: 'Test Feature' }
+      const result = await commandExecutor.execute('now', params, testProjectPath)
+
+      expect(result.context.params).toEqual(params)
+    })
+
+    it('should handle different commands', async () => {
+      const commands = ['now', 'done', 'next', 'ship']
+
+      for (const cmd of commands) {
+        const result = await commandExecutor.execute(cmd, {}, testProjectPath)
+        expect(result.success).toBe(true)
+      }
+    })
+
+    it('should handle non-existent command', async () => {
+      const result = await commandExecutor.execute('nonexistent', {}, testProjectPath)
+
+      expect(result.success).toBe(false)
+      expect(result.error).toBeDefined()
+      expect(result.error).toContain('Template not found')
+    })
+
+    it('should include all execution data', async () => {
+      const result = await commandExecutor.execute('now', {}, testProjectPath)
+
+      expect(result).toHaveProperty('success')
+      expect(result).toHaveProperty('template')
+      expect(result).toHaveProperty('context')
+      expect(result).toHaveProperty('state')
+      expect(result).toHaveProperty('prompt')
+    })
+  })
+
+  describe('executeTool()', () => {
+    it('should execute allowed tool', async () => {
+      const allowedTools = ['Read', 'Write', 'Bash']
+      const result = await commandExecutor.executeTool('Read', [__filename], allowedTools)
+
+      expect(result).toBeDefined()
+    })
+
+    it('should throw error for disallowed tool', async () => {
+      const allowedTools = ['Read']
+
+      await expect(commandExecutor.executeTool('Write', ['file.txt', 'content'], allowedTools)).rejects.toThrow(
+        'Tool Write not allowed for this command'
+      )
+    })
+
+    it('should execute Read tool', async () => {
+      const allowedTools = ['Read']
+      const content = await commandExecutor.executeTool('Read', [__filename], allowedTools)
+
+      expect(content).toBeDefined()
+      expect(content).toContain('Command Executor')
+    })
+
+    it('should handle tool errors', async () => {
+      const allowedTools = ['Read']
+
+      await expect(commandExecutor.executeTool('UnknownTool', [], allowedTools)).rejects.toThrow()
+    })
+
+    it('should check permissions before execution', async () => {
+      const allowedTools = ['Read']
+
+      // Bash not allowed
+      await expect(commandExecutor.executeTool('Bash', ['echo test'], allowedTools)).rejects.toThrow(
+        'not allowed'
+      )
+    })
+  })
+
+  describe('executeSimple()', () => {
+    it('should execute simple command', async () => {
+      const executionFn = async (_tools, _context) => {
+        return { message: 'Executed successfully' }
+      }
+
+      const result = await commandExecutor.executeSimple('now', executionFn, testProjectPath)
+
+      expect(result.success).toBe(true)
+      expect(result.result).toEqual({ message: 'Executed successfully' })
+    })
+
+    it('should provide tools to execution function', async () => {
+      const executionFn = async (_tools, _context) => {
+        expect(_tools).toHaveProperty('read')
+        expect(_tools).toHaveProperty('write')
+        expect(_tools).toHaveProperty('bash')
+        return { tools: 'available' }
+      }
+
+      const result = await commandExecutor.executeSimple('now', executionFn, testProjectPath)
+
+      expect(result.success).toBe(true)
+    })
+
+    it('should provide context to execution function', async () => {
+      const executionFn = async (_tools, _context) => {
+        expect(_context).toBeDefined()
+        expect(_context).toHaveProperty('projectId')
+        expect(_context).toHaveProperty('projectPath')
+        return { context: 'received' }
+      }
+
+      const result = await commandExecutor.executeSimple('now', executionFn, testProjectPath)
+
+      expect(result.success).toBe(true)
+    })
+
+    it('should enforce tool permissions', async () => {
+      const executionFn = async (_tools, _context) => {
+        // Try to use a disallowed tool
+        await _tools.write('/test/file.txt', 'content')
+      }
+
+      const result = await commandExecutor.executeSimple('now', executionFn, testProjectPath)
+
+      // Should fail if Write is not in allowed tools for 'now'
+      expect(result.success).toBe(false)
+    })
+
+    it('should handle execution errors', async () => {
+      const executionFn = async (_tools, _context) => {
+        throw new Error('Execution failed')
+      }
+
+      const result = await commandExecutor.executeSimple('now', executionFn, testProjectPath)
+
+      expect(result.success).toBe(false)
+      expect(result.error).toContain('Execution failed')
+    })
+
+    it('should work with allowed tools', async () => {
+      const executionFn = async (_tools, _context) => {
+        // Read is typically allowed
+        const content = await _tools.read(__filename)
+        return { readSuccess: content !== null }
+      }
+
+      const result = await commandExecutor.executeSimple('now', executionFn, testProjectPath)
+
+      expect(result.success).toBe(true)
+      expect(result.result.readSuccess).toBe(true)
+    })
+  })
+
+  describe('Integration', () => {
+    it('should execute full command flow', async () => {
+      const result = await commandExecutor.execute('now', { task: 'Test Task' }, testProjectPath)
+
+      expect(result.success).toBe(true)
+      expect(result.template).toBeDefined()
+      expect(result.context).toBeDefined()
+      expect(result.state).toBeDefined()
+      expect(result.prompt).toBeDefined()
+
+      // Prompt should include the template content
+      expect(result.prompt).toContain(result.template.content)
+
+      // Context should include parameters
+      expect(result.context.params.task).toBe('Test Task')
+    })
+
+    it('should build proper prompt structure', async () => {
+      const result = await commandExecutor.execute('now', {}, testProjectPath)
+
+      expect(result.prompt).toContain('# Command Instructions')
+      expect(result.prompt).toContain('## Project Context')
+      expect(result.prompt).toContain('## Current State')
+      expect(result.prompt).toContain('## Execute')
+    })
+  })
+})

package/core/__tests__/agentic/context-builder.test.js

@@ -0,0 +1,160 @@
+import { describe, it, expect } from 'vitest'
+import contextBuilder from '../../agentic/context-builder.js'
+import path from 'path'
+
+describe('Context Builder', () => {
+  const testProjectPath = process.cwd()
+
+  describe('build()', () => {
+    it('should build context with all required fields', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+
+      expect(context).toBeDefined()
+      expect(context).toHaveProperty('projectId')
+      expect(context).toHaveProperty('projectPath')
+      expect(context).toHaveProperty('globalPath')
+      expect(context).toHaveProperty('paths')
+      expect(context).toHaveProperty('params')
+      expect(context).toHaveProperty('timestamp')
+      expect(context).toHaveProperty('date')
+    })
+
+    it('should include all file paths', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+
+      expect(context.paths).toHaveProperty('now')
+      expect(context.paths).toHaveProperty('next')
+      expect(context.paths).toHaveProperty('context')
+      expect(context.paths).toHaveProperty('shipped')
+      expect(context.paths).toHaveProperty('metrics')
+      expect(context.paths).toHaveProperty('ideas')
+      expect(context.paths).toHaveProperty('roadmap')
+      expect(context.paths).toHaveProperty('memory')
+      expect(context.paths).toHaveProperty('analysis')
+    })
+
+    it('should use correct project path', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+
+      expect(context.projectPath).toBe(testProjectPath)
+    })
+
+    it('should include command parameters', async () => {
+      const params = { taskName: 'test task', feature: 'test feature' }
+      const context = await contextBuilder.build(testProjectPath, params)
+
+      expect(context.params).toEqual(params)
+    })
+
+    it('should include timestamp', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+
+      expect(context.timestamp).toBeDefined()
+      expect(typeof context.timestamp).toBe('string')
+      expect(new Date(context.timestamp).toString()).not.toBe('Invalid Date')
+    })
+
+    it('should include date', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+
+      expect(context.date).toBeDefined()
+      expect(typeof context.date).toBe('string')
+    })
+
+    it('should build global path from project ID', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+
+      expect(context.globalPath).toContain('.prjct-cli')
+      expect(context.globalPath).toContain('projects')
+      expect(context.globalPath).toContain(context.projectId)
+    })
+  })
+
+  describe('loadState()', () => {
+    it('should load state from context', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+      const state = await contextBuilder.loadState(context)
+
+      expect(state).toBeDefined()
+      expect(typeof state).toBe('object')
+    })
+
+    it('should return null for non-existent files', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+      const state = await contextBuilder.loadState(context)
+
+      // Some files might not exist
+      Object.values(state).forEach((value) => {
+        expect(value === null || typeof value === 'string').toBe(true)
+      })
+    })
+
+    it('should load existing files as strings', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+      const state = await contextBuilder.loadState(context)
+
+      // At least some state values should be strings (if files exist)
+      const hasStrings = Object.values(state).some((value) => typeof value === 'string')
+      expect(typeof hasStrings).toBe('boolean')
+    })
+  })
+
+  describe('fileExists()', () => {
+    it('should return true for existing file', async () => {
+      const exists = await contextBuilder.fileExists(__filename)
+
+      expect(exists).toBe(true)
+    })
+
+    it('should return false for non-existent file', async () => {
+      const exists = await contextBuilder.fileExists('/nonexistent/path/file.txt')
+
+      expect(exists).toBe(false)
+    })
+
+    it('should work with package.json', async () => {
+      const packagePath = path.join(process.cwd(), 'package.json')
+      const exists = await contextBuilder.fileExists(packagePath)
+
+      expect(exists).toBe(true)
+    })
+  })
+
+  describe('Path Construction', () => {
+    it('should construct paths with correct structure', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+
+      expect(context.paths.now).toContain('core/now.md')
+      expect(context.paths.next).toContain('core/next.md')
+      expect(context.paths.context).toContain('core/context.md')
+      expect(context.paths.shipped).toContain('progress/shipped.md')
+      expect(context.paths.metrics).toContain('progress/metrics.md')
+      expect(context.paths.ideas).toContain('planning/ideas.md')
+      expect(context.paths.roadmap).toContain('planning/roadmap.md')
+      expect(context.paths.memory).toContain('memory/context.jsonl')
+      expect(context.paths.analysis).toContain('analysis/repo-summary.md')
+    })
+
+    it('should use global path for all file paths', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+
+      Object.values(context.paths).forEach((filePath) => {
+        expect(filePath).toContain(context.globalPath)
+      })
+    })
+  })
+
+  describe('Empty Parameters', () => {
+    it('should handle empty command params', async () => {
+      const context = await contextBuilder.build(testProjectPath, {})
+
+      expect(context.params).toEqual({})
+    })
+
+    it('should handle undefined command params', async () => {
+      const context = await contextBuilder.build(testProjectPath)
+
+      expect(context.params).toEqual({})
+    })
+  })
+})

package/core/__tests__/agentic/prompt-builder.test.js

@@ -0,0 +1,212 @@
+import { describe, it, expect } from 'vitest'
+import promptBuilder from '../../agentic/prompt-builder.js'
+
+describe('Prompt Builder', () => {
+  const mockTemplate = {
+    frontmatter: {
+      'allowed-tools': ['Read', 'Write', 'Bash'],
+    },
+    content: '# Command: Test\n\nExecute test command.',
+  }
+
+  const mockContext = {
+    projectId: 'test-project-123',
+    projectPath: '/test/path',
+    globalPath: '/global/path',
+    timestamp: '2025-10-04T12:00:00Z',
+    date: '2025-10-04',
+    params: {},
+    paths: {
+      now: '/global/path/core/now.md',
+      next: '/global/path/core/next.md',
+    },
+  }
+
+  const mockState = {
+    now: '# Current Task\n\nTest task in progress',
+    next: '# Priority Queue\n\nTask 1, Task 2',
+    context: null, // Simulate non-existent file
+  }
+
+  describe('build()', () => {
+    it('should build a complete prompt', () => {
+      const prompt = promptBuilder.build(mockTemplate, mockContext, mockState)
+
+      expect(prompt).toBeDefined()
+      expect(typeof prompt).toBe('string')
+      expect(prompt.length).toBeGreaterThan(0)
+    })
+
+    it('should include command instructions', () => {
+      const prompt = promptBuilder.build(mockTemplate, mockContext, mockState)
+
+      expect(prompt).toContain('# Command Instructions')
+      expect(prompt).toContain('Execute test command')
+    })
+
+    it('should include allowed tools', () => {
+      const prompt = promptBuilder.build(mockTemplate, mockContext, mockState)
+
+      expect(prompt).toContain('## Allowed Tools')
+      expect(prompt).toContain('Read, Write, Bash')
+    })
+
+    it('should include project context', () => {
+      const prompt = promptBuilder.build(mockTemplate, mockContext, mockState)
+
+      expect(prompt).toContain('## Project Context')
+      expect(prompt).toContain('Project ID: test-project-123')
+      expect(prompt).toContain('Timestamp: 2025-10-04T12:00:00Z')
+    })
+
+    it('should include current state', () => {
+      const prompt = promptBuilder.build(mockTemplate, mockContext, mockState)
+
+      expect(prompt).toContain('## Current State')
+      expect(prompt).toContain('### now')
+      expect(prompt).toContain('Test task in progress')
+      expect(prompt).toContain('### next')
+      expect(prompt).toContain('Task 1, Task 2')
+    })
+
+    it('should exclude null or empty state values', () => {
+      const prompt = promptBuilder.build(mockTemplate, mockContext, mockState)
+
+      // Should not include 'context' since it's null
+      expect(prompt).not.toContain('### context')
+    })
+
+    it('should include parameters when present', () => {
+      const contextWithParams = {
+        ...mockContext,
+        params: {
+          taskName: 'Test Task',
+          feature: 'Test Feature',
+        },
+      }
+
+      const prompt = promptBuilder.build(mockTemplate, contextWithParams, mockState)
+
+      expect(prompt).toContain('## Parameters')
+      expect(prompt).toContain('taskName: Test Task')
+      expect(prompt).toContain('feature: Test Feature')
+    })
+
+    it('should exclude parameters section when empty', () => {
+      const prompt = promptBuilder.build(mockTemplate, mockContext, mockState)
+
+      // Should not include Parameters section since params is empty
+      const hasParametersSection = prompt.includes('## Parameters')
+      expect(hasParametersSection).toBe(false)
+    })
+
+    it('should include final execution instructions', () => {
+      const prompt = promptBuilder.build(mockTemplate, mockContext, mockState)
+
+      expect(prompt).toContain('## Execute')
+      expect(prompt).toContain('execute the command')
+      expect(prompt).toContain('Use ONLY the allowed tools')
+      expect(prompt).toContain('do not follow rigid if/else rules')
+    })
+
+    it('should handle template without allowed-tools', () => {
+      const templateNoTools = {
+        frontmatter: {},
+        content: 'Simple command',
+      }
+
+      const prompt = promptBuilder.build(templateNoTools, mockContext, mockState)
+
+      expect(prompt).toBeDefined()
+      expect(prompt).toContain('Simple command')
+      // Should not have Allowed Tools section
+      expect(prompt).not.toContain('## Allowed Tools')
+    })
+
+    it('should handle empty state', () => {
+      const emptyState = {}
+
+      const prompt = promptBuilder.build(mockTemplate, mockContext, emptyState)
+
+      expect(prompt).toBeDefined()
+      expect(prompt).toContain('## Current State')
+      // But no actual state entries
+    })
+
+    it('should format state content in code blocks', () => {
+      const prompt = promptBuilder.build(mockTemplate, mockContext, mockState)
+
+      expect(prompt).toContain('```')
+      expect(prompt).toMatch(/```\n# Current Task/)
+    })
+  })
+
+  describe('buildAnalysis()', () => {
+    it('should build analysis prompt', () => {
+      const prompt = promptBuilder.buildAnalysis('repository', mockContext)
+
+      expect(prompt).toBeDefined()
+      expect(typeof prompt).toBe('string')
+    })
+
+    it('should include analysis type', () => {
+      const prompt = promptBuilder.buildAnalysis('repository', mockContext)
+
+      expect(prompt).toContain('# Analyze: repository')
+    })
+
+    it('should include project context', () => {
+      const prompt = promptBuilder.buildAnalysis('repository', mockContext)
+
+      expect(prompt).toContain('## Project Context')
+      expect(prompt).toContain('Path: /test/path')
+      expect(prompt).toContain('ID: test-project-123')
+    })
+
+    it('should include analysis instructions', () => {
+      const prompt = promptBuilder.buildAnalysis('repository', mockContext)
+
+      expect(prompt).toContain('Read the project context')
+      expect(prompt).toContain('provide your analysis')
+      expect(prompt).toContain('No predetermined patterns')
+    })
+
+    it('should work with different analysis types', () => {
+      const types = ['repository', 'feature', 'bug', 'performance']
+
+      types.forEach((type) => {
+        const prompt = promptBuilder.buildAnalysis(type, mockContext)
+        expect(prompt).toContain(`# Analyze: ${type}`)
+      })
+    })
+  })
+
+  describe('Prompt Structure', () => {
+    it('should have clear sections in order', () => {
+      const prompt = promptBuilder.build(mockTemplate, mockContext, mockState)
+
+      const instructionsIndex = prompt.indexOf('# Command Instructions')
+      const toolsIndex = prompt.indexOf('## Allowed Tools')
+      const contextIndex = prompt.indexOf('## Project Context')
+      const stateIndex = prompt.indexOf('## Current State')
+      const executeIndex = prompt.indexOf('## Execute')
+
+      expect(instructionsIndex).toBeGreaterThan(-1)
+      expect(toolsIndex).toBeGreaterThan(instructionsIndex)
+      expect(contextIndex).toBeGreaterThan(toolsIndex)
+      expect(stateIndex).toBeGreaterThan(contextIndex)
+      expect(executeIndex).toBeGreaterThan(stateIndex)
+    })
+
+    it('should use proper markdown formatting', () => {
+      const prompt = promptBuilder.build(mockTemplate, mockContext, mockState)
+
+      // Should have proper headings
+      expect(prompt).toMatch(/^# /m)
+      expect(prompt).toMatch(/^## /m)
+
+      // Should have code blocks
+      expect(prompt).toContain('```')
+    })
+  })
+})