prjct-cli 0.11.5 → 0.12.0

package/core/__tests__/utils/{date-helper.test.js → date-helper.test.ts}

@@ -3,7 +3,8 @@
  * Tests for centralized date operations and formatting
  */
 
-const {
+import { describe, it, expect, beforeEach, afterEach, setSystemTime } from 'bun:test'
+import {
   formatDate,
   formatMonth,
   getTodayKey,
@@ -20,7 +21,7 @@ const {
   calculateDuration,
   getStartOfDay,
   getEndOfDay,
-} = require('../../utils/date-helper')
+} from '../../utils/date-helper'
 
 describe('DateHelper', () => {
   describe('formatDate', () => {
@@ -64,12 +65,9 @@ describe('DateHelper', () => {
 
   describe('getTodayKey', () => {
     it('should return today in YYYY-MM-DD format', () => {
-      vi.useFakeTimers()
-      vi.setSystemTime(new Date(2025, 5, 15)) // June 15, 2025
-
+      setSystemTime(new Date(2025, 5, 15)) // June 15, 2025
       expect(getTodayKey()).toBe('2025-06-15')
-
-      vi.useRealTimers()
+      setSystemTime()
     })
   })
 
@@ -93,14 +91,12 @@ describe('DateHelper', () => {
     it('should pad month values', () => {
       const date = new Date(2025, 0, 15) // Jan 15, 2025
       const result = getYearMonthDay(date)
-
       expect(result.month).toBe('01')
     })
 
     it('should pad day values', () => {
       const date = new Date(2025, 5, 7) // June 7, 2025
       const result = getYearMonthDay(date)
-
       expect(result.day).toBe('07')
     })
   })
@@ -122,12 +118,9 @@ describe('DateHelper', () => {
 
   describe('getTimestamp', () => {
     it('should return ISO timestamp', () => {
-      vi.useFakeTimers()
-      vi.setSystemTime(new Date('2025-10-04T14:30:00.000Z'))
-
+      setSystemTime(new Date('2025-10-04T14:30:00.000Z'))
       expect(getTimestamp()).toBe('2025-10-04T14:30:00.000Z')
-
-      vi.useRealTimers()
+      setSystemTime()
     })
 
     it('should include milliseconds', () => {
@@ -138,12 +131,11 @@ describe('DateHelper', () => {
 
   describe('getDaysAgo', () => {
     beforeEach(() => {
-      vi.useFakeTimers()
-      vi.setSystemTime(new Date(2025, 9, 15)) // Oct 15, 2025
+      setSystemTime(new Date(2025, 9, 15)) // Oct 15, 2025
     })
 
     afterEach(() => {
-      vi.useRealTimers()
+      setSystemTime()
     })
 
     it('should calculate past dates correctly', () => {
@@ -164,12 +156,11 @@ describe('DateHelper', () => {
 
   describe('getDaysFromNow', () => {
     beforeEach(() => {
-      vi.useFakeTimers()
-      vi.setSystemTime(new Date(2025, 9, 15)) // Oct 15, 2025
+      setSystemTime(new Date(2025, 9, 15)) // Oct 15, 2025
     })
 
     afterEach(() => {
-      vi.useRealTimers()
+      setSystemTime()
     })
 
     it('should calculate future dates correctly', () => {
@@ -241,12 +232,11 @@ describe('DateHelper', () => {
 
   describe('isToday', () => {
     beforeEach(() => {
-      vi.useFakeTimers()
-      vi.setSystemTime(new Date(2025, 9, 15)) // Oct 15, 2025
+      setSystemTime(new Date(2025, 9, 15)) // Oct 15, 2025
     })
 
     afterEach(() => {
-      vi.useRealTimers()
+      setSystemTime()
     })
 
     it('should return true for today', () => {
@@ -272,12 +262,11 @@ describe('DateHelper', () => {
 
   describe('isWithinLastDays', () => {
     beforeEach(() => {
-      vi.useFakeTimers()
-      vi.setSystemTime(new Date(2025, 9, 15, 12, 0, 0)) // Oct 15, 2025 at noon
+      setSystemTime(new Date(2025, 9, 15, 12, 0, 0)) // Oct 15, 2025 at noon
     })
 
     afterEach(() => {
-      vi.useRealTimers()
+      setSystemTime()
     })
 
     it('should return true for dates within range', () => {
@@ -296,7 +285,8 @@ describe('DateHelper', () => {
     })
 
     it('should include boundary date', () => {
-      const boundary = new Date(2025, 9, 8) // exactly 7 days ago
+      // Oct 8 at noon is exactly 7 days before Oct 15 at noon
+      const boundary = new Date(2025, 9, 8, 12, 0, 0)
       expect(isWithinLastDays(boundary, 7)).toBe(true)
     })
   })
@@ -339,13 +329,12 @@ describe('DateHelper', () => {
     })
 
     it('should default to now if no end date', () => {
-      vi.useFakeTimers()
-      vi.setSystemTime(new Date('2025-10-15T12:00:00.000Z'))
+      setSystemTime(new Date('2025-10-15T12:00:00.000Z'))
 
       const start = new Date('2025-10-15T10:00:00.000Z')
       expect(calculateDuration(start)).toBe('2h 0m')
 
-      vi.useRealTimers()
+      setSystemTime()
     })
 
     it('should handle short durations', () => {

package/core/__tests__/utils/{output.test.js → output.test.ts}

@@ -3,18 +3,16 @@
  * Minimal output system for prjct-cli
  */
 
-const out = require('../../utils/output')
+import { describe, it, expect, beforeEach, afterEach, spyOn } from 'bun:test'
+import out from '../../utils/output'
 
 describe('Output Module', () => {
-  let consoleLogSpy
-  let stdoutWriteSpy
+  let consoleLogSpy: ReturnType<typeof spyOn>
+  let stdoutWriteSpy: ReturnType<typeof spyOn>
 
   beforeEach(() => {
-    // Mock console.log
-    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
-    // Mock process.stdout.write
-    stdoutWriteSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => {})
-    // Ensure spinner is stopped before each test
+    consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
+    stdoutWriteSpy = spyOn(process.stdout, 'write').mockImplementation(() => true)
     out.stop()
   })
 
@@ -39,7 +37,6 @@ describe('Output Module', () => {
       out.done(longMessage)
 
       const output = consoleLogSpy.mock.calls[0][0]
-      // Should be truncated to ~65 chars + checkmark
       expect(output.length).toBeLessThan(80)
     })
 
@@ -90,20 +87,16 @@ describe('Output Module', () => {
   })
 
   describe('spin()', () => {
-    it('should start spinner with message', () => {
-      vi.useFakeTimers()
-
+    it('should start spinner with message', async () => {
       out.spin('loading')
 
-      // Advance timer to trigger interval
-      vi.advanceTimersByTime(100)
+      await new Promise(resolve => setTimeout(resolve, 150))
 
       expect(stdoutWriteSpy).toHaveBeenCalled()
       const output = stdoutWriteSpy.mock.calls[0][0]
       expect(output).toContain('loading')
 
       out.stop()
-      vi.useRealTimers()
     })
 
     it('should return self for chaining', () => {
@@ -114,19 +107,14 @@ describe('Output Module', () => {
   })
 
   describe('stop()', () => {
-    it('should stop spinner and clear line', () => {
-      vi.useFakeTimers()
-
+    it('should stop spinner and clear line', async () => {
       out.spin('loading')
-      vi.advanceTimersByTime(100)
+      await new Promise(resolve => setTimeout(resolve, 150))
 
       stdoutWriteSpy.mockClear()
       out.stop()
 
-      // Should write clearing spaces
       expect(stdoutWriteSpy).toHaveBeenCalled()
-
-      vi.useRealTimers()
     })
 
     it('should be safe to call multiple times', () => {
@@ -151,8 +139,8 @@ describe('Output Module', () => {
     })
 
     it('should handle null/undefined messages', () => {
-      expect(() => out.done(null)).not.toThrow()
-      expect(() => out.done(undefined)).not.toThrow()
+      expect(() => out.done(null as unknown as string)).not.toThrow()
+      expect(() => out.done(undefined as unknown as string)).not.toThrow()
     })
 
     it('should handle messages with special characters', () => {

package/core/agentic/agent-router.ts

@@ -0,0 +1,137 @@
+/**
+ * Agent Router
+ * Orchestrates agent loading and context building for Claude delegation.
+ *
+ * @module agentic/agent-router
+ * @version 2.0.0
+ */
+
+import fs from 'fs/promises'
+import path from 'path'
+import configManager from '../infrastructure/config-manager'
+import pathManager from '../infrastructure/path-manager'
+
+interface Agent {
+  name: string
+  content: string
+}
+
+interface AssignmentContext {
+  task: string
+  availableAgents: string[]
+  projectPath: string
+  projectId: string | null
+  _template: string
+}
+
+/**
+ * Routes tasks to specialized agents based on Claude's decisions.
+ * Handles agent loading, context building, and usage logging.
+ */
+class AgentRouter {
+  projectId: string | null = null
+  agentsPath: string | null = null
+
+  /**
+   * Initialize router with project context
+   */
+  async initialize(projectPath: string): Promise<void> {
+    this.projectId = await configManager.getProjectId(projectPath)
+    this.agentsPath = pathManager.getPath(this.projectId!, 'agents')
+  }
+
+  /**
+   * Load all available agents from project
+   */
+  async loadAvailableAgents(): Promise<Agent[]> {
+    try {
+      const files = await fs.readdir(this.agentsPath!)
+      const agents: Agent[] = []
+
+      for (const file of files) {
+        if (file.endsWith('.md')) {
+          const name = file.replace('.md', '')
+          const content = await fs.readFile(path.join(this.agentsPath!, file), 'utf-8')
+          agents.push({ name, content })
+        }
+      }
+
+      return agents
+    } catch {
+      return []
+    }
+  }
+
+  /**
+   * Get list of available agent names
+   */
+  async getAgentNames(): Promise<string[]> {
+    const agents = await this.loadAvailableAgents()
+    return agents.map((a) => a.name)
+  }
+
+  /**
+   * Load a specific agent by name
+   */
+  async loadAgent(name: string): Promise<Agent | null> {
+    try {
+      const filePath = path.join(this.agentsPath!, `${name}.md`)
+      const content = await fs.readFile(filePath, 'utf-8')
+      return { name, content }
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Build context for Claude to decide agent assignment
+   */
+  async buildAssignmentContext(
+    task: string | { description?: string },
+    projectPath: string
+  ): Promise<AssignmentContext> {
+    const agents = await this.getAgentNames()
+
+    return {
+      task: typeof task === 'string' ? task : task.description || '',
+      availableAgents: agents,
+      projectPath,
+      projectId: this.projectId,
+      // Claude reads this and decides via template
+      _template: 'templates/agent-assignment.md',
+    }
+  }
+
+  /**
+   * Log agent usage to JSONL file
+   */
+  async logUsage(
+    task: string | { description?: string },
+    agent: string | { name?: string },
+    _projectPath: string
+  ): Promise<void> {
+    try {
+      const logPath = path.join(
+        process.env.HOME || '',
+        '.prjct-cli',
+        'projects',
+        this.projectId || '',
+        'agent-usage.jsonl'
+      )
+
+      const entry =
+        JSON.stringify({
+          timestamp: new Date().toISOString(),
+          task: typeof task === 'string' ? task : task.description,
+          agent: typeof agent === 'string' ? agent : agent.name,
+          projectId: this.projectId,
+        }) + '\n'
+
+      await fs.appendFile(logPath, entry)
+    } catch {
+      // Silent fail for logging
+    }
+  }
+}
+
+export default AgentRouter

package/core/agentic/chain-of-thought.ts

@@ -0,0 +1,228 @@
+/**
+ * Chain of Thought Reasoning
+ * Implements step-by-step reasoning for complex commands
+ *
+ * @module agentic/chain-of-thought
+ * @version 1.0.0
+ */
+
+interface Context {
+  projectId?: string | null
+  projectPath: string
+  params: Record<string, unknown>
+}
+
+interface State {
+  now?: string | null
+  next?: string | null
+  shipped?: string | null
+  analysis?: string | null
+  [key: string]: unknown
+}
+
+interface ReasoningStep {
+  step: string
+  passed: boolean
+  details?: string
+}
+
+interface ReasoningResult {
+  commandName: string
+  reasoning: {
+    steps: ReasoningStep[]
+    allPassed: boolean
+    criticalIssues: string[]
+  } | null
+  plan: string[]
+  confidence: number
+}
+
+/**
+ * Commands that require chain of thought reasoning
+ */
+const REASONING_REQUIRED_COMMANDS = ['ship', 'feature', 'spec', 'cleanup', 'migrate']
+
+/**
+ * Check if command requires reasoning
+ */
+function requiresReasoning(commandName: string): boolean {
+  return REASONING_REQUIRED_COMMANDS.includes(commandName)
+}
+
+/**
+ * Reason through a command before execution
+ */
+async function reason(commandName: string, context: Context, state: State): Promise<ReasoningResult> {
+  const steps: ReasoningStep[] = []
+  const plan: string[] = []
+  const criticalIssues: string[] = []
+
+  switch (commandName) {
+    case 'ship':
+      // Check prerequisites
+      if (state.now && !state.now.includes('No current task')) {
+        steps.push({ step: 'Has active task', passed: true })
+      } else {
+        steps.push({ step: 'Has active task', passed: false, details: 'No active task to ship' })
+        criticalIssues.push('No active task')
+      }
+
+      // Check if there's content to ship
+      if (state.shipped) {
+        steps.push({ step: 'Shipped log accessible', passed: true })
+      } else {
+        steps.push({ step: 'Shipped log accessible', passed: false, details: 'shipped.md not found' })
+      }
+
+      // Plan
+      plan.push('Read current task from now.md')
+      plan.push('Calculate duration')
+      plan.push('Append to shipped.md')
+      plan.push('Clear now.md')
+      plan.push('Update metrics')
+      break
+
+    case 'feature':
+      // Check if description provided
+      if (context.params.description || context.params.feature) {
+        steps.push({ step: 'Has feature description', passed: true })
+      } else {
+        steps.push({ step: 'Has feature description', passed: false, details: 'No description provided' })
+        criticalIssues.push('Missing feature description')
+      }
+
+      // Check roadmap accessibility
+      if (state.analysis) {
+        steps.push({ step: 'Project analyzed', passed: true })
+      } else {
+        steps.push({ step: 'Project analyzed', passed: false, details: 'Run /p:sync first' })
+      }
+
+      // Plan
+      plan.push('Parse feature description')
+      plan.push('Generate tasks breakdown')
+      plan.push('Add to roadmap.md')
+      plan.push('Add tasks to next.md')
+      plan.push('Suggest starting first task')
+      break
+
+    case 'spec':
+      // Check if feature name provided
+      if (context.params.feature || context.params.name) {
+        steps.push({ step: 'Has spec name', passed: true })
+      } else {
+        steps.push({ step: 'Has spec name', passed: false, details: 'No spec name provided' })
+        criticalIssues.push('Missing spec name')
+      }
+
+      // Plan
+      plan.push('Generate spec template')
+      plan.push('Analyze requirements')
+      plan.push('Create spec file')
+      plan.push('Link to roadmap')
+      break
+
+    case 'cleanup':
+      // Check for analysis
+      if (state.analysis) {
+        steps.push({ step: 'Has code analysis', passed: true })
+      } else {
+        steps.push({ step: 'Has code analysis', passed: false, details: 'Run /p:analyze first' })
+      }
+
+      // Plan
+      plan.push('Scan for unused code')
+      plan.push('Identify dead imports')
+      plan.push('List files to clean')
+      plan.push('Show preview')
+      plan.push('Wait for approval')
+      plan.push('Execute cleanup')
+      break
+
+    case 'migrate':
+      // Always warn for migrate
+      steps.push({
+        step: 'Migration safety check',
+        passed: true,
+        details: 'Will require manual approval',
+      })
+
+      // Plan
+      plan.push('Analyze current state')
+      plan.push('Generate migration plan')
+      plan.push('Show affected files')
+      plan.push('Request approval')
+      plan.push('Execute migration')
+      plan.push('Verify results')
+      break
+
+    default:
+      // Generic plan
+      plan.push('Execute command')
+      break
+  }
+
+  // Calculate confidence
+  const passedSteps = steps.filter((s) => s.passed).length
+  const totalSteps = steps.length
+  const confidence = totalSteps > 0 ? passedSteps / totalSteps : 1
+
+  return {
+    commandName,
+    reasoning:
+      steps.length > 0
+        ? {
+            steps,
+            allPassed: criticalIssues.length === 0,
+            criticalIssues,
+          }
+        : null,
+    plan,
+    confidence,
+  }
+}
+
+/**
+ * Format reasoning plan for display
+ */
+function formatPlan(result: ReasoningResult): string {
+  const lines: string[] = []
+
+  lines.push(`📋 Chain of Thought: ${result.commandName}`)
+  lines.push('')
+
+  if (result.reasoning) {
+    lines.push('Steps:')
+    result.reasoning.steps.forEach((step) => {
+      const icon = step.passed ? '✅' : '❌'
+      lines.push(`  ${icon} ${step.step}`)
+      if (step.details) {
+        lines.push(`      ${step.details}`)
+      }
+    })
+    lines.push('')
+
+    if (result.reasoning.criticalIssues.length > 0) {
+      lines.push('Critical Issues:')
+      result.reasoning.criticalIssues.forEach((issue) => {
+        lines.push(`  ⚠️  ${issue}`)
+      })
+      lines.push('')
+    }
+  }
+
+  if (result.plan.length > 0) {
+    lines.push('Plan:')
+    result.plan.forEach((step, i) => {
+      lines.push(`  ${i + 1}. ${step}`)
+    })
+    lines.push('')
+  }
+
+  lines.push(`Confidence: ${Math.round(result.confidence * 100)}%`)
+
+  return lines.join('\n')
+}
+
+export { requiresReasoning, reason, formatPlan, REASONING_REQUIRED_COMMANDS }
+export default { requiresReasoning, reason, formatPlan }