prjct-cli 0.7.1 → 0.7.3

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('```')
+    })
+  })
+})

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

@@ -0,0 +1,164 @@
+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

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