prjct-cli 1.11.0 → 1.13.0

package/core/__tests__/agentic/analysis-injection.test.ts

@@ -0,0 +1,377 @@
+/**
+ * Analysis Injection Tests (PRJ-260)
+ *
+ * Tests for injecting sealed analysis data into task context:
+ * - Prompt builder renders analysis in ground_truth section
+ * - Anti-hallucination block enriched with analysis data
+ * - Graceful degradation when no analysis available
+ */
+
+import { beforeEach, describe, expect, it } from 'bun:test'
+import {
+  buildAntiHallucinationBlock,
+  type ProjectGroundTruth,
+} from '../../agentic/anti-hallucination'
+import promptBuilder from '../../agentic/prompt-builder'
+import type { OrchestratorContext, SealedAnalysisContext } from '../../types'
+
+// =============================================================================
+// Test Fixtures
+// =============================================================================
+
+const mockSealedAnalysis: SealedAnalysisContext = {
+  languages: ['TypeScript', 'JavaScript'],
+  frameworks: ['Hono', 'Zod'],
+  packageManager: 'bun',
+  sourceDir: 'core/',
+  testDir: 'core/__tests__/',
+  fileCount: 295,
+  patterns: [
+    {
+      name: 'StorageManager pattern',
+      description: 'All storage uses StorageManager base class with read/write/update',
+      location: 'core/storage/',
+    },
+    {
+      name: 'Zod schemas',
+      description: 'Runtime validation with Zod for all data structures',
+    },
+  ],
+  antiPatterns: [
+    {
+      issue: 'Direct fs.writeFile without StorageManager',
+      file: 'core/storage/legacy.ts',
+      suggestion: 'Use StorageManager.write() instead',
+    },
+  ],
+  status: 'sealed',
+  commitHash: 'abc123def456',
+}
+
+function makeOrchestratorContext(
+  sealedAnalysis: SealedAnalysisContext | null = mockSealedAnalysis
+): OrchestratorContext {
+  return {
+    detectedDomains: ['backend', 'testing'],
+    primaryDomain: 'backend',
+    agents: [],
+    skills: [],
+    requiresFragmentation: false,
+    subtasks: null,
+    project: {
+      id: 'test-project',
+      ecosystem: 'TypeScript',
+      conventions: ['Hono', 'Zod'],
+    },
+    sealedAnalysis,
+  }
+}
+
+// =============================================================================
+// Prompt Builder — Ground Truth Section
+// =============================================================================
+
+describe('Analysis Injection in Prompt Builder (PRJ-260)', () => {
+  beforeEach(() => {
+    promptBuilder.resetContext()
+  })
+
+  it('should render sealed analysis in ground truth section', async () => {
+    const template = {
+      frontmatter: { description: 'Test task' },
+      content: '## Instructions\nDo the work',
+    }
+    const context = { projectPath: '/test/project', files: ['a.ts'] }
+    const orcCtx = makeOrchestratorContext()
+
+    const prompt = await promptBuilder.build(
+      template,
+      context,
+      {},
+      null,
+      null,
+      null,
+      null,
+      null,
+      orcCtx
+    )
+
+    // Should contain analysis data
+    expect(prompt).toContain('Languages**: TypeScript, JavaScript')
+    expect(prompt).toContain('Frameworks**: Hono, Zod')
+    expect(prompt).toContain('Package Manager**: bun')
+    expect(prompt).toContain('Source Dir**: core/')
+    expect(prompt).toContain('Test Dir**: core/__tests__/')
+    expect(prompt).toContain('Files Analyzed**: 295')
+    expect(prompt).toContain('Analysis Status**: sealed')
+    expect(prompt).toContain('abc123de') // truncated commit hash
+  })
+
+  it('should render code patterns from sealed analysis', async () => {
+    const template = {
+      frontmatter: { description: 'Test' },
+      content: '## Do',
+    }
+    const context = { projectPath: '/test', files: [] }
+    const orcCtx = makeOrchestratorContext()
+
+    const prompt = await promptBuilder.build(
+      template,
+      context,
+      {},
+      null,
+      null,
+      null,
+      null,
+      null,
+      orcCtx
+    )
+
+    expect(prompt).toContain('Code Patterns (Follow These)')
+    expect(prompt).toContain('StorageManager pattern')
+    expect(prompt).toContain('All storage uses StorageManager base class')
+    expect(prompt).toContain('core/storage/')
+    expect(prompt).toContain('Zod schemas')
+  })
+
+  it('should render anti-patterns from sealed analysis', async () => {
+    const template = {
+      frontmatter: { description: 'Test' },
+      content: '## Do',
+    }
+    const context = { projectPath: '/test', files: [] }
+    const orcCtx = makeOrchestratorContext()
+
+    const prompt = await promptBuilder.build(
+      template,
+      context,
+      {},
+      null,
+      null,
+      null,
+      null,
+      null,
+      orcCtx
+    )
+
+    expect(prompt).toContain('Anti-Patterns (Avoid These)')
+    expect(prompt).toContain('Direct fs.writeFile without StorageManager')
+    expect(prompt).toContain('core/storage/legacy.ts')
+    expect(prompt).toContain('Use StorageManager.write() instead')
+  })
+
+  it('should gracefully handle null sealed analysis', async () => {
+    const template = {
+      frontmatter: { description: 'Test' },
+      content: '## Do',
+    }
+    const context = { projectPath: '/test', files: [] }
+    const orcCtx = makeOrchestratorContext(null)
+
+    const prompt = await promptBuilder.build(
+      template,
+      context,
+      {},
+      null,
+      null,
+      null,
+      null,
+      null,
+      orcCtx
+    )
+
+    // Should still have basic project analysis
+    expect(prompt).toContain('PROJECT ANALYSIS')
+    expect(prompt).toContain('Ecosystem**: TypeScript')
+    // Should NOT have analysis-specific fields
+    expect(prompt).not.toContain('Languages**:')
+    expect(prompt).not.toContain('Code Patterns (Follow These)')
+    expect(prompt).not.toContain('Anti-Patterns (Avoid These)')
+  })
+
+  it('should handle empty patterns and anti-patterns', async () => {
+    const template = {
+      frontmatter: { description: 'Test' },
+      content: '## Do',
+    }
+    const context = { projectPath: '/test', files: [] }
+    const emptyAnalysis: SealedAnalysisContext = {
+      ...mockSealedAnalysis,
+      patterns: [],
+      antiPatterns: [],
+    }
+    const orcCtx = makeOrchestratorContext(emptyAnalysis)
+
+    const prompt = await promptBuilder.build(
+      template,
+      context,
+      {},
+      null,
+      null,
+      null,
+      null,
+      null,
+      orcCtx
+    )
+
+    expect(prompt).toContain('Languages**: TypeScript, JavaScript')
+    expect(prompt).not.toContain('Code Patterns (Follow These)')
+    expect(prompt).not.toContain('Anti-Patterns (Avoid These)')
+  })
+
+  it('should handle no orchestrator context at all', async () => {
+    const template = {
+      frontmatter: { description: 'Test' },
+      content: '## Do',
+    }
+    const context = { projectPath: '/test', files: [] }
+
+    const prompt = await promptBuilder.build(
+      template,
+      context,
+      {},
+      null,
+      null,
+      null,
+      null,
+      null,
+      null
+    )
+
+    // Should not crash, should have fallback rules
+    expect(prompt).toContain('CONSTRAINTS')
+    expect(prompt).not.toContain('PROJECT ANALYSIS')
+  })
+})
+
+// =============================================================================
+// Anti-Hallucination Block — Analysis Enrichment
+// =============================================================================
+
+describe('Anti-Hallucination Block with Analysis (PRJ-260)', () => {
+  it('should include analysis languages in AVAILABLE list', () => {
+    const truth: ProjectGroundTruth = {
+      projectPath: '/test',
+      language: 'TypeScript',
+      techStack: ['Hono'],
+      analysisLanguages: ['TypeScript', 'JavaScript', 'Shell'],
+      analysisFrameworks: ['Hono', 'Vitest'],
+    }
+
+    const block = buildAntiHallucinationBlock(truth)
+
+    expect(block).toContain('AVAILABLE in this project:')
+    // TypeScript and Hono should not be duplicated
+    expect(block).toContain('JavaScript')
+    expect(block).toContain('Shell')
+    expect(block).toContain('Vitest')
+  })
+
+  it('should deduplicate analysis data with existing tech stack (case-insensitive)', () => {
+    const truth: ProjectGroundTruth = {
+      projectPath: '/test',
+      language: 'TypeScript',
+      framework: 'Hono',
+      techStack: ['Zod'],
+      analysisLanguages: ['typescript'], // lowercase duplicate
+      analysisFrameworks: ['hono', 'Zod'], // lowercase duplicates
+    }
+
+    const block = buildAntiHallucinationBlock(truth)
+
+    // Count occurrences — each should appear exactly once
+    const typescriptMatches = block.match(/typescript/gi)
+    expect(typescriptMatches?.length).toBe(1)
+
+    const honoMatches = block.match(/hono/gi)
+    expect(honoMatches?.length).toBe(1)
+  })
+
+  it('should show package manager from analysis', () => {
+    const truth: ProjectGroundTruth = {
+      projectPath: '/test',
+      analysisPackageManager: 'bun',
+    }
+
+    const block = buildAntiHallucinationBlock(truth)
+
+    expect(block).toContain('PACKAGE MANAGER: bun')
+  })
+
+  it('should work without any analysis data', () => {
+    const truth: ProjectGroundTruth = {
+      projectPath: '/test',
+      language: 'Python',
+    }
+
+    const block = buildAntiHallucinationBlock(truth)
+
+    expect(block).toContain('AVAILABLE in this project: Python')
+    expect(block).not.toContain('PACKAGE MANAGER:')
+  })
+
+  it('should handle empty analysis arrays gracefully', () => {
+    const truth: ProjectGroundTruth = {
+      projectPath: '/test',
+      analysisLanguages: [],
+      analysisFrameworks: [],
+    }
+
+    const block = buildAntiHallucinationBlock(truth)
+
+    // Should not contain AVAILABLE line (no tech to show)
+    expect(block).not.toContain('AVAILABLE in this project:')
+    expect(block).toContain('CONSTRAINTS')
+  })
+})
+
+// =============================================================================
+// SealedAnalysisContext Type
+// =============================================================================
+
+describe('SealedAnalysisContext type (PRJ-260)', () => {
+  it('should accept valid sealed analysis data', () => {
+    const analysis: SealedAnalysisContext = {
+      languages: ['TypeScript'],
+      frameworks: ['Hono'],
+      fileCount: 100,
+      patterns: [{ name: 'test', description: 'test pattern' }],
+      antiPatterns: [{ issue: 'test', file: 'test.ts', suggestion: 'fix it' }],
+      status: 'sealed',
+    }
+
+    expect(analysis.languages).toEqual(['TypeScript'])
+    expect(analysis.status).toBe('sealed')
+  })
+
+  it('should accept draft status', () => {
+    const analysis: SealedAnalysisContext = {
+      languages: [],
+      frameworks: [],
+      fileCount: 0,
+      patterns: [],
+      antiPatterns: [],
+      status: 'draft',
+    }
+
+    expect(analysis.status).toBe('draft')
+  })
+
+  it('should accept optional fields', () => {
+    const analysis: SealedAnalysisContext = {
+      languages: ['Python'],
+      frameworks: [],
+      fileCount: 50,
+      patterns: [],
+      antiPatterns: [],
+      status: 'sealed',
+      packageManager: 'pip',
+      sourceDir: 'src/',
+      testDir: 'tests/',
+      commitHash: 'abc123',
+    }
+
+    expect(analysis.packageManager).toBe('pip')
+    expect(analysis.commitHash).toBe('abc123')
+  })
+})

package/core/__tests__/storage/subtask-handoff.test.ts

@@ -0,0 +1,237 @@
+/**
+ * Subtask Handoff Tests (PRJ-262)
+ *
+ * Tests for mandatory subtask output and handoff:
+ * - SubtaskCompletionDataSchema validation
+ * - SubtaskSummarySchema required fields
+ * - validateSubtaskCompletion helper
+ * - Backward compatibility with old state.json
+ */
+
+import { describe, expect, it } from 'bun:test'
+import {
+  SubtaskCompletionDataSchema,
+  SubtaskSchema,
+  SubtaskSummarySchema,
+  validateSubtaskCompletion,
+} from '../../schemas/state'
+
+// =============================================================================
+// SubtaskSummarySchema — outputForNextAgent is now required
+// =============================================================================
+
+describe('SubtaskSummarySchema', () => {
+  const validSummary = {
+    title: 'Implement auth middleware',
+    description: 'Added JWT verification to all protected routes',
+    filesChanged: [
+      { path: 'src/middleware/auth.ts', action: 'created' as const },
+      { path: 'src/routes/api.ts', action: 'modified' as const },
+    ],
+    whatWasDone: ['Created JWT middleware', 'Applied to API routes'],
+    outputForNextAgent:
+      'Auth middleware is in place. Next subtask should add role-based access control.',
+  }
+
+  it('should parse a valid summary with all required fields', () => {
+    const result = SubtaskSummarySchema.parse(validSummary)
+    expect(result.outputForNextAgent).toBe(validSummary.outputForNextAgent)
+    expect(result.whatWasDone).toHaveLength(2)
+  })
+
+  it('should reject missing outputForNextAgent', () => {
+    const { outputForNextAgent, ...withoutOutput } = validSummary
+    expect(() => SubtaskSummarySchema.parse(withoutOutput)).toThrow()
+  })
+
+  it('should reject empty outputForNextAgent', () => {
+    expect(() => SubtaskSummarySchema.parse({ ...validSummary, outputForNextAgent: '' })).toThrow()
+  })
+
+  it('should reject empty whatWasDone array', () => {
+    expect(() => SubtaskSummarySchema.parse({ ...validSummary, whatWasDone: [] })).toThrow()
+  })
+
+  it('should allow optional notes', () => {
+    const result = SubtaskSummarySchema.parse({ ...validSummary, notes: 'Watch for rate limits' })
+    expect(result.notes).toBe('Watch for rate limits')
+  })
+
+  it('should allow missing notes', () => {
+    const result = SubtaskSummarySchema.parse(validSummary)
+    expect(result.notes).toBeUndefined()
+  })
+})
+
+// =============================================================================
+// SubtaskCompletionDataSchema — validates completion requirements
+// =============================================================================
+
+describe('SubtaskCompletionDataSchema', () => {
+  const validCompletion = {
+    output: 'Implemented auth middleware with JWT verification',
+    summary: {
+      title: 'Auth middleware',
+      description: 'JWT verification for protected routes',
+      filesChanged: [{ path: 'src/auth.ts', action: 'created' as const }],
+      whatWasDone: ['Created JWT middleware'],
+      outputForNextAgent: 'Middleware ready, add RBAC next.',
+    },
+  }
+
+  it('should parse valid completion data', () => {
+    const result = SubtaskCompletionDataSchema.parse(validCompletion)
+    expect(result.output).toBe(validCompletion.output)
+    expect(result.summary.outputForNextAgent).toBe('Middleware ready, add RBAC next.')
+  })
+
+  it('should reject missing output', () => {
+    const { output, ...withoutOutput } = validCompletion
+    expect(() => SubtaskCompletionDataSchema.parse(withoutOutput)).toThrow()
+  })
+
+  it('should reject empty output', () => {
+    expect(() => SubtaskCompletionDataSchema.parse({ ...validCompletion, output: '' })).toThrow()
+  })
+
+  it('should reject missing summary', () => {
+    expect(() => SubtaskCompletionDataSchema.parse({ output: 'some output' })).toThrow()
+  })
+
+  it('should reject summary without outputForNextAgent', () => {
+    const badSummary = { ...validCompletion.summary }
+    // @ts-expect-error - intentionally testing invalid data
+    delete badSummary.outputForNextAgent
+    expect(() => SubtaskCompletionDataSchema.parse({ output: 'ok', summary: badSummary })).toThrow()
+  })
+})
+
+// =============================================================================
+// validateSubtaskCompletion helper
+// =============================================================================
+
+describe('validateSubtaskCompletion', () => {
+  const validData = {
+    output: 'Task done',
+    summary: {
+      title: 'Test',
+      description: 'Testing',
+      filesChanged: [],
+      whatWasDone: ['Did the thing'],
+      outputForNextAgent: 'Context for next.',
+    },
+  }
+
+  it('should return success for valid data', () => {
+    const result = validateSubtaskCompletion(validData)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.output).toBe('Task done')
+    }
+  })
+
+  it('should return errors for missing output', () => {
+    const result = validateSubtaskCompletion({ summary: validData.summary })
+    expect(result.success).toBe(false)
+    if (!result.success) {
+      expect(result.errors.length).toBeGreaterThan(0)
+      expect(result.errors.some((e) => e.includes('output'))).toBe(true)
+    }
+  })
+
+  it('should return errors for empty whatWasDone', () => {
+    const result = validateSubtaskCompletion({
+      output: 'ok',
+      summary: { ...validData.summary, whatWasDone: [] },
+    })
+    expect(result.success).toBe(false)
+    if (!result.success) {
+      expect(result.errors.some((e) => e.includes('whatWasDone'))).toBe(true)
+    }
+  })
+
+  it('should return errors for completely invalid data', () => {
+    const result = validateSubtaskCompletion({})
+    expect(result.success).toBe(false)
+    if (!result.success) {
+      expect(result.errors.length).toBeGreaterThan(0)
+    }
+  })
+})
+
+// =============================================================================
+// Backward Compatibility
+// =============================================================================
+
+describe('backward compatibility', () => {
+  it('should parse old SubtaskSchema without summary or output', () => {
+    const oldSubtask = {
+      id: 'subtask-1',
+      description: 'Old subtask without handoff',
+      domain: 'backend',
+      agent: 'backend.md',
+      status: 'completed' as const,
+      dependsOn: [],
+      startedAt: '2026-01-01T00:00:00.000Z',
+      completedAt: '2026-01-01T01:00:00.000Z',
+      // No output, no summary — old format
+    }
+    const result = SubtaskSchema.parse(oldSubtask)
+    expect(result.output).toBeUndefined()
+    expect(result.summary).toBeUndefined()
+    expect(result.status).toBe('completed')
+  })
+
+  it('should parse pending subtask without completion fields', () => {
+    const pending = {
+      id: 'subtask-2',
+      description: 'Pending subtask',
+      domain: 'frontend',
+      agent: 'frontend.md',
+      status: 'pending' as const,
+      dependsOn: ['subtask-1'],
+    }
+    const result = SubtaskSchema.parse(pending)
+    expect(result.status).toBe('pending')
+    expect(result.output).toBeUndefined()
+    expect(result.summary).toBeUndefined()
+  })
+
+  it('should parse subtask with output but no summary (transition format)', () => {
+    const transitional = {
+      id: 'subtask-1',
+      description: 'Transitional format',
+      domain: 'backend',
+      agent: 'backend.md',
+      status: 'completed' as const,
+      dependsOn: [],
+      output: 'Done with basic output',
+      // No summary yet
+    }
+    const result = SubtaskSchema.parse(transitional)
+    expect(result.output).toBe('Done with basic output')
+    expect(result.summary).toBeUndefined()
+  })
+
+  it('should parse subtask with full handoff data', () => {
+    const withHandoff = {
+      id: 'subtask-1',
+      description: 'Full handoff format',
+      domain: 'backend',
+      agent: 'backend.md',
+      status: 'completed' as const,
+      dependsOn: [],
+      output: 'Implemented the feature',
+      summary: {
+        title: 'Backend API',
+        description: 'Created REST endpoints',
+        filesChanged: [{ path: 'src/api.ts', action: 'created' as const }],
+        whatWasDone: ['Created endpoints', 'Added validation'],
+        outputForNextAgent: 'API is ready at /api/v1. Add auth next.',
+      },
+    }
+    const result = SubtaskSchema.parse(withHandoff)
+    expect(result.summary?.outputForNextAgent).toBe('API is ready at /api/v1. Add auth next.')
+    expect(result.summary?.whatWasDone).toHaveLength(2)
+  })
+})

package/core/agentic/anti-hallucination.ts

@@ -47,6 +47,12 @@ export const ProjectGroundTruthSchema = z.object({
   fileCount: z.number().optional(),
   /** Available agent names (e.g., ['backend', 'testing']) */
   availableAgents: z.array(z.string()).default([]),
+  /** Sealed analysis languages — used to ground available tech (PRJ-260) */
+  analysisLanguages: z.array(z.string()).default([]),
+  /** Sealed analysis frameworks — used to ground available tech (PRJ-260) */
+  analysisFrameworks: z.array(z.string()).default([]),
+  /** Package manager from sealed analysis (PRJ-260) */
+  analysisPackageManager: z.string().optional(),
 })
 
 export type ProjectGroundTruth = z.input<typeof ProjectGroundTruthSchema>
@@ -79,16 +85,32 @@ export function buildAntiHallucinationBlock(truth: ProjectGroundTruth): string {
 
   parts.push('## CONSTRAINTS (Read Before Acting)\n')
 
-  // 1. Explicit availability
+  // 1. Explicit availability (enriched by sealed analysis — PRJ-260)
   const available: string[] = []
   if (truth.language) available.push(truth.language)
   if (truth.framework) available.push(truth.framework)
   const techStack = truth.techStack ?? []
   available.push(...techStack.filter((t) => t !== truth.framework))
+  // Merge languages/frameworks from sealed analysis (deduped)
+  const analysisLangs = truth.analysisLanguages ?? []
+  const analysisFrameworks = truth.analysisFrameworks ?? []
+  for (const lang of analysisLangs) {
+    if (!available.some((a) => a.toLowerCase() === lang.toLowerCase())) {
+      available.push(lang)
+    }
+  }
+  for (const fw of analysisFrameworks) {
+    if (!available.some((a) => a.toLowerCase() === fw.toLowerCase())) {
+      available.push(fw)
+    }
+  }
 
   if (available.length > 0) {
     parts.push(`AVAILABLE in this project: ${available.join(', ')}`)
   }
+  if (truth.analysisPackageManager) {
+    parts.push(`PACKAGE MANAGER: ${truth.analysisPackageManager}`)
+  }
 
   // 2. Explicit unavailability from domain flags
   if (truth.domains) {