prjct-cli 1.10.0 → 1.12.0

package/core/__tests__/storage/analysis-storage.test.ts

@@ -0,0 +1,277 @@
+/**
+ * Analysis Storage Tests (PRJ-263)
+ *
+ * Tests for sealable analysis lifecycle:
+ * - Schema validation (draft/verified/sealed)
+ * - Signature computation and verification
+ * - Staleness detection
+ * - Draft preservation on re-sync
+ * - Backward compatibility
+ */
+
+import { describe, expect, it } from 'bun:test'
+import {
+  AnalysisItemSchema,
+  AnalysisStatusSchema,
+  parseAnalysis,
+  safeParseAnalysis,
+} from '../../schemas/analysis'
+
+// =============================================================================
+// Schema Validation
+// =============================================================================
+
+describe('AnalysisStatusSchema', () => {
+  it('should accept valid statuses', () => {
+    expect(AnalysisStatusSchema.parse('draft')).toBe('draft')
+    expect(AnalysisStatusSchema.parse('verified')).toBe('verified')
+    expect(AnalysisStatusSchema.parse('sealed')).toBe('sealed')
+  })
+
+  it('should reject invalid statuses', () => {
+    expect(() => AnalysisStatusSchema.parse('pending')).toThrow()
+    expect(() => AnalysisStatusSchema.parse('active')).toThrow()
+    expect(() => AnalysisStatusSchema.parse('')).toThrow()
+  })
+})
+
+describe('AnalysisItemSchema', () => {
+  const validDraft = {
+    projectId: 'test-project-123',
+    languages: ['TypeScript'],
+    frameworks: ['Hono'],
+    configFiles: ['tsconfig.json'],
+    fileCount: 295,
+    patterns: [{ name: 'Service pattern', description: 'Classes with dependency injection' }],
+    antiPatterns: [],
+    analyzedAt: '2026-02-08T20:00:00.000Z',
+    status: 'draft' as const,
+    commitHash: 'abc1234',
+  }
+
+  it('should parse a valid draft analysis', () => {
+    const result = AnalysisItemSchema.parse(validDraft)
+    expect(result.status).toBe('draft')
+    expect(result.commitHash).toBe('abc1234')
+    expect(result.projectId).toBe('test-project-123')
+  })
+
+  it('should default status to draft when not provided', () => {
+    const { status, ...withoutStatus } = validDraft
+    const result = AnalysisItemSchema.parse(withoutStatus)
+    expect(result.status).toBe('draft')
+  })
+
+  it('should parse a sealed analysis with signature', () => {
+    const sealed = {
+      ...validDraft,
+      status: 'sealed' as const,
+      signature: 'sha256-abc123def456',
+      sealedAt: '2026-02-08T21:00:00.000Z',
+    }
+    const result = AnalysisItemSchema.parse(sealed)
+    expect(result.status).toBe('sealed')
+    expect(result.signature).toBe('sha256-abc123def456')
+    expect(result.sealedAt).toBe('2026-02-08T21:00:00.000Z')
+  })
+
+  it('should accept optional fields as undefined', () => {
+    const minimal = {
+      projectId: 'test',
+      languages: [],
+      frameworks: [],
+      configFiles: [],
+      fileCount: 0,
+      patterns: [],
+      antiPatterns: [],
+      analyzedAt: '2026-02-08T20:00:00.000Z',
+    }
+    const result = AnalysisItemSchema.parse(minimal)
+    expect(result.status).toBe('draft')
+    expect(result.commitHash).toBeUndefined()
+    expect(result.signature).toBeUndefined()
+    expect(result.sealedAt).toBeUndefined()
+    expect(result.modelMetadata).toBeUndefined()
+  })
+
+  it('should reject missing required fields', () => {
+    expect(() => AnalysisItemSchema.parse({})).toThrow()
+    expect(() => AnalysisItemSchema.parse({ projectId: 'test' })).toThrow()
+  })
+})
+
+describe('parseAnalysis / safeParseAnalysis', () => {
+  it('should parse valid data', () => {
+    const data = {
+      projectId: 'test',
+      languages: ['TypeScript'],
+      frameworks: [],
+      configFiles: [],
+      fileCount: 10,
+      patterns: [],
+      antiPatterns: [],
+      analyzedAt: '2026-02-08T20:00:00.000Z',
+    }
+    const result = parseAnalysis(data)
+    expect(result.projectId).toBe('test')
+    expect(result.status).toBe('draft')
+  })
+
+  it('should return success for safeParseAnalysis with valid data', () => {
+    const data = {
+      projectId: 'test',
+      languages: [],
+      frameworks: [],
+      configFiles: [],
+      fileCount: 0,
+      patterns: [],
+      antiPatterns: [],
+      analyzedAt: '2026-02-08T20:00:00.000Z',
+    }
+    const result = safeParseAnalysis(data)
+    expect(result.success).toBe(true)
+  })
+
+  it('should return failure for safeParseAnalysis with invalid data', () => {
+    const result = safeParseAnalysis({ invalid: true })
+    expect(result.success).toBe(false)
+  })
+})
+
+// =============================================================================
+// Staleness Detection (pure function tests)
+// =============================================================================
+
+describe('staleness detection', () => {
+  // Test checkStaleness method from AnalysisStorage
+  it('should detect stale analysis when commits differ', () => {
+    const { analysisStorage } = require('../../storage/analysis-storage')
+    const result = analysisStorage.checkStaleness('abc1234', 'def5678')
+    expect(result.isStale).toBe(true)
+    expect(result.sealedCommit).toBe('abc1234')
+    expect(result.currentCommit).toBe('def5678')
+  })
+
+  it('should detect fresh analysis when commits match', () => {
+    const { analysisStorage } = require('../../storage/analysis-storage')
+    const result = analysisStorage.checkStaleness('abc1234', 'abc1234')
+    expect(result.isStale).toBe(false)
+  })
+
+  it('should handle null sealed commit', () => {
+    const { analysisStorage } = require('../../storage/analysis-storage')
+    const result = analysisStorage.checkStaleness(null, 'abc1234')
+    expect(result.isStale).toBe(false)
+    expect(result.message).toContain('No sealed analysis')
+  })
+
+  it('should handle null current commit', () => {
+    const { analysisStorage } = require('../../storage/analysis-storage')
+    const result = analysisStorage.checkStaleness('abc1234', null)
+    expect(result.isStale).toBe(true)
+    expect(result.message).toContain('Cannot determine')
+  })
+})
+
+// =============================================================================
+// Signature Computation (determinism test)
+// =============================================================================
+
+describe('signature computation', () => {
+  it('should produce deterministic signatures for same input', () => {
+    const { createHash } = require('node:crypto')
+
+    const analysis = {
+      projectId: 'test',
+      languages: ['TypeScript'],
+      frameworks: ['Hono'],
+      configFiles: [],
+      fileCount: 100,
+      patterns: [],
+      antiPatterns: [],
+      analyzedAt: '2026-02-08T20:00:00.000Z',
+      commitHash: 'abc1234',
+    }
+
+    const canonical = {
+      projectId: analysis.projectId,
+      languages: analysis.languages,
+      frameworks: analysis.frameworks,
+      packageManager: undefined,
+      sourceDir: undefined,
+      testDir: undefined,
+      configFiles: analysis.configFiles,
+      fileCount: analysis.fileCount,
+      patterns: analysis.patterns,
+      antiPatterns: analysis.antiPatterns,
+      analyzedAt: analysis.analyzedAt,
+      commitHash: analysis.commitHash,
+    }
+
+    const sig1 = createHash('sha256').update(JSON.stringify(canonical)).digest('hex')
+    const sig2 = createHash('sha256').update(JSON.stringify(canonical)).digest('hex')
+
+    expect(sig1).toBe(sig2)
+    expect(sig1).toHaveLength(64) // SHA-256 hex = 64 chars
+  })
+
+  it('should produce different signatures for different inputs', () => {
+    const { createHash } = require('node:crypto')
+
+    const data1 = JSON.stringify({ projectId: 'a', fileCount: 1 })
+    const data2 = JSON.stringify({ projectId: 'b', fileCount: 2 })
+
+    const sig1 = createHash('sha256').update(data1).digest('hex')
+    const sig2 = createHash('sha256').update(data2).digest('hex')
+
+    expect(sig1).not.toBe(sig2)
+  })
+})
+
+// =============================================================================
+// Backward Compatibility
+// =============================================================================
+
+describe('backward compatibility', () => {
+  it('should parse old analysis.json without seal fields', () => {
+    const oldFormat = {
+      projectId: 'old-project',
+      languages: ['JavaScript'],
+      frameworks: ['Express'],
+      configFiles: ['package.json'],
+      fileCount: 50,
+      patterns: [],
+      antiPatterns: [],
+      analyzedAt: '2025-12-01T00:00:00.000Z',
+      // No status, commitHash, signature, sealedAt
+    }
+
+    const result = AnalysisItemSchema.parse(oldFormat)
+    expect(result.status).toBe('draft') // Default
+    expect(result.commitHash).toBeUndefined()
+    expect(result.signature).toBeUndefined()
+    expect(result.sealedAt).toBeUndefined()
+  })
+
+  it('should parse old analysis with modelMetadata but no seal fields', () => {
+    const oldWithModel = {
+      projectId: 'old-project',
+      languages: ['TypeScript'],
+      frameworks: [],
+      configFiles: [],
+      fileCount: 10,
+      patterns: [],
+      antiPatterns: [],
+      analyzedAt: '2026-01-15T00:00:00.000Z',
+      modelMetadata: {
+        provider: 'claude',
+        model: 'sonnet',
+        recordedAt: '2026-01-15T00:00:00.000Z',
+      },
+    }
+
+    const result = AnalysisItemSchema.parse(oldWithModel)
+    expect(result.status).toBe('draft')
+    expect(result.modelMetadata?.provider).toBe('claude')
+  })
+})

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/prompt-builder.ts

@@ -800,6 +800,24 @@ class PromptBuilder {
         if (currentSubtask.dependsOn.length > 0) {
           parts.push(`Dependencies: ${currentSubtask.dependsOn.join(', ')}\n`)
         }
+
+        // Inject previous subtask handoff for context continuity (PRJ-262)
+        if (currentSubtask.handoff) {
+          const h = currentSubtask.handoff
+          parts.push('\n### Previous Subtask Handoff\n\n')
+          parts.push(`**From:** ${h.fromSubtask}\n\n`)
+          parts.push('**What was done:**\n')
+          for (const item of h.whatWasDone) {
+            parts.push(`- ${item}\n`)
+          }
+          if (h.filesChanged.length > 0) {
+            parts.push('\n**Files changed:**\n')
+            for (const f of h.filesChanged) {
+              parts.push(`- \`${f.path}\` (${f.action})\n`)
+            }
+          }
+          parts.push(`\n**Context for this subtask:**\n${h.outputForNextAgent}\n`)
+        }
       }
       parts.push('\n')
     }

package/core/commands/analysis.ts

@@ -12,6 +12,7 @@ import commandInstaller from '../infrastructure/command-installer'
 import { formatCost } from '../schemas/metrics'
 import { createStalenessChecker, memoryService, syncService } from '../services'
 import { formatDiffPreview, formatFullDiff, generateSyncDiff } from '../services/diff-generator'
+import { analysisStorage } from '../storage/analysis-storage'
 import { metricsStorage } from '../storage/metrics-storage'
 import type { AnalyzeOptions, CommandResult, ProjectContext } from '../types'
 import { getErrorMessage } from '../types/fs'
@@ -805,6 +806,9 @@ export class AnalysisCommands extends PrjctCommandsBase {
       // Get session info
       const sessionInfo = await checker.getSessionInfo(projectId)
 
+      // Get analysis status (PRJ-263)
+      const analysisStatus = await analysisStorage.getStatus(projectId)
+
       // JSON output mode
       if (options.json) {
         console.log(
@@ -812,9 +816,13 @@ export class AnalysisCommands extends PrjctCommandsBase {
             success: true,
             ...status,
             session: sessionInfo,
+            analysis: analysisStatus,
           })
         )
-        return { success: true, data: { ...status, session: sessionInfo } }
+        return {
+          success: true,
+          data: { ...status, session: sessionInfo, analysis: analysisStatus },
+        }
       }
 
       // Human-readable output
@@ -822,9 +830,22 @@ export class AnalysisCommands extends PrjctCommandsBase {
       console.log(checker.formatStatus(status))
       console.log('')
       console.log(checker.formatSessionInfo(sessionInfo))
+
+      // Show analysis status (PRJ-263)
+      if (analysisStatus.hasSealed || analysisStatus.hasDraft) {
+        console.log('')
+        console.log('Analysis:')
+        if (analysisStatus.hasSealed) {
+          console.log(`  Sealed: ${analysisStatus.sealedCommit} (${analysisStatus.sealedAt})`)
+        }
+        if (analysisStatus.hasDraft) {
+          console.log(`  Draft: ${analysisStatus.draftCommit} (pending seal)`)
+        }
+      }
+
       console.log('')
 
-      return { success: true, data: { ...status, session: sessionInfo } }
+      return { success: true, data: { ...status, session: sessionInfo, analysis: analysisStatus } }
     } catch (error) {
       const errMsg = getErrorMessage(error)
       if (options.json) {
@@ -836,6 +857,100 @@ export class AnalysisCommands extends PrjctCommandsBase {
     }
   }
 
+  /**
+   * prjct seal - Seal the current draft analysis (PRJ-263)
+   *
+   * Locks the current draft with a SHA-256 signature.
+   * Only sealed analysis feeds task context.
+   */
+  async seal(
+    projectPath: string = process.cwd(),
+    options: { json?: boolean } = {}
+  ): Promise<CommandResult> {
+    try {
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
+
+      const projectId = await configManager.getProjectId(projectPath)
+      if (!projectId) {
+        if (options.json) {
+          console.log(JSON.stringify({ success: false, error: 'No project ID found' }))
+        }
+        return { success: false, error: 'No project ID found' }
+      }
+
+      const result = await analysisStorage.seal(projectId)
+
+      if (options.json) {
+        console.log(
+          JSON.stringify({
+            success: result.success,
+            signature: result.signature,
+            error: result.error,
+          })
+        )
+        return { success: result.success, error: result.error }
+      }
+
+      if (!result.success) {
+        out.fail(result.error || 'Seal failed')
+        return { success: false, error: result.error }
+      }
+
+      out.done('Analysis sealed')
+      console.log(`  Signature: ${result.signature?.substring(0, 16)}...`)
+      console.log('')
+
+      return { success: true, data: { signature: result.signature } }
+    } catch (error) {
+      const errMsg = getErrorMessage(error)
+      if (options.json) {
+        console.log(JSON.stringify({ success: false, error: errMsg }))
+      } else {
+        out.fail(errMsg)
+      }
+      return { success: false, error: errMsg }
+    }
+  }
+
+  /**
+   * prjct verify - Verify integrity of sealed analysis (PRJ-263)
+   */
+  async verify(
+    projectPath: string = process.cwd(),
+    options: { json?: boolean } = {}
+  ): Promise<CommandResult> {
+    try {
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
+
+      const projectId = await configManager.getProjectId(projectPath)
+      if (!projectId) {
+        return { success: false, error: 'No project ID found' }
+      }
+
+      const result = await analysisStorage.verify(projectId)
+
+      if (options.json) {
+        console.log(JSON.stringify(result))
+        return { success: result.valid }
+      }
+
+      if (result.valid) {
+        out.done(result.message)
+      } else {
+        out.fail(result.message)
+      }
+      console.log('')
+
+      return { success: result.valid, data: result }
+    } catch (error) {
+      const errMsg = getErrorMessage(error)
+      out.fail(errMsg)
+      return { success: false, error: errMsg }
+    }
+  }
+
   /**
    * Get session activity stats from today's events
    * @see PRJ-89