prjct-cli 0.10.0 → 0.10.2

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

@@ -1,204 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import promptBuilder from '../../agentic/prompt-builder.js'
-
-describe('Prompt Builder', () => {
-  const mockTemplate = {
-    frontmatter: {
-      'allowed-tools': ['Read', 'Write', 'Bash'],
-      description: 'Execute test command',
-    },
-    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('TASK: Execute test command')
-    })
-
-    it('should include allowed tools', () => {
-      const prompt = promptBuilder.build(mockTemplate, mockContext, mockState)
-
-      expect(prompt).toContain('TOOLS: Read, Write, Bash')
-    })
-
-    it('should include project context', () => {
-      // Context is now handled differently in the new prompt builder (filtered context)
-      // The prompt builder doesn't explicitly list project ID/Timestamp anymore in the main prompt
-      // It focuses on the task and tools
-      const prompt = promptBuilder.build(mockTemplate, mockContext, mockState)
-      expect(prompt).toBeDefined()
-    })
-
-    it('should include current state', () => {
-      const prompt = promptBuilder.build(mockTemplate, mockContext, mockState)
-
-      expect(prompt).toContain('STATE:')
-      expect(prompt).toContain('now: # Current Task')
-      expect(prompt).toContain('Test task in progress')
-      expect(prompt).toContain('next: # Priority Queue')
-      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: {
-          task: 'Test Task',
-          description: 'Test Feature',
-        },
-      }
-
-      const prompt = promptBuilder.build(mockTemplate, contextWithParams, mockState)
-
-      expect(prompt).toContain('INPUT: Test Task')
-    })
-
-    it('should exclude parameters section when empty', () => {
-      const prompt = promptBuilder.build(mockTemplate, mockContext, mockState)
-
-      // Should not include INPUT section since params is empty
-      const hasInputSection = prompt.includes('INPUT:')
-      expect(hasInputSection).toBe(false)
-    })
-
-    it('should include final execution instructions', () => {
-      const prompt = promptBuilder.build(mockTemplate, mockContext, mockState)
-
-      expect(prompt).toContain('## PROCESS ENFORCEMENT')
-      expect(prompt).toContain('FOLLOW the Flow strictly')
-      expect(prompt).toContain('EXECUTE: Follow flow. Use tools. Decide.')
-    })
-
-    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 TOOLS section
-      expect(prompt).not.toContain('TOOLS:')
-    })
-
-    it('should handle empty state', () => {
-      const emptyState = {}
-
-      const prompt = promptBuilder.build(mockTemplate, mockContext, emptyState)
-
-      expect(prompt).toBeDefined()
-      expect(prompt).not.toContain('STATE:')
-    })
-
-    it('should format state content', () => {
-      const prompt = promptBuilder.build(mockTemplate, mockContext, mockState)
-
-      expect(prompt).toContain('STATE:')
-      expect(prompt).toContain('now: # 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 taskIndex = prompt.indexOf('TASK:')
-      const toolsIndex = prompt.indexOf('TOOLS:')
-      const stateIndex = prompt.indexOf('STATE:')
-      const enforcementIndex = prompt.indexOf('## PROCESS ENFORCEMENT')
-      const executeIndex = prompt.indexOf('EXECUTE:')
-
-      expect(taskIndex).toBeGreaterThan(-1)
-      expect(toolsIndex).toBeGreaterThan(taskIndex)
-      expect(stateIndex).toBeGreaterThan(toolsIndex)
-      expect(enforcementIndex).toBeGreaterThan(stateIndex)
-      expect(executeIndex).toBeGreaterThan(enforcementIndex)
-    })
-
-    it('should use proper formatting', () => {
-      const prompt = promptBuilder.build(mockTemplate, mockContext, mockState)
-
-      // Should have proper headings
-      expect(prompt).toContain('TASK:')
-      expect(prompt).toContain('TOOLS:')
-    })
-  })
-})

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')
-    })
-  })
-})