prjct-cli 0.10.0 → 0.10.3

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # Changelog
 
+## [0.10.3] - 2025-11-27
+
+### Fixed
+
+- **Global CLAUDE.md Auto-Update** - Now updates `~/.claude/CLAUDE.md` on every sync/analyze/init
+  - `/p:sync`: Updates global config after generating agents
+  - `/p:analyze`: Updates global config after analysis
+  - `/p:init`: Updates global config for all init modes
+  - Ensures Claude always has latest prjct instructions
+
+## [0.10.2] - 2025-11-27
+
+### Added
+
+- **Dynamic Project Context for Claude** - Claude now actually uses generated agents and project context
+  - New `core/context-sync.js` module generates project-specific CLAUDE.md
+  - Context file stored in global storage: `~/.prjct-cli/projects/{projectId}/CLAUDE.md`
+  - Auto-generates on `/p:sync`, `/p:analyze`, and `/p:init`
+  - Reads ALL agents dynamically (agents vary per project)
+  - Extracts: stack, current task, priority queue, active features
+  - Instructions added to global CLAUDE.md template for Claude to read project context
+
+### Changed
+
+- **`/p:sync` Command** - Now generates dynamic project context after syncing agents
+- **`/p:analyze` Command** - Now generates dynamic project context after analysis
+- **Global CLAUDE.md Template** - Added instructions for Claude to read project-specific context
+  - New "🤖 Project Context (OBLIGATORIO)" section
+  - Instructs Claude to read `~/.prjct-cli/projects/{projectId}/CLAUDE.md` before working
+
+### Technical Details
+
+- **New Files**:
+  - `core/context-sync.js` (~140 lines) - Context generation with dynamic agent reading
+
+- **Modified Files**:
+  - `core/commands.js` - Added context sync calls to sync() and analyze()
+  - `templates/global/CLAUDE.md` - Added project context reading instructions
+
+- **Architecture Decision**: Context lives in global storage (NOT in repo) to avoid being overwritten by commits
+
 ## [0.10.1] - 2025-11-24
 
 ### Added

package/core/__tests__/agentic/memory-system.test.js

@@ -0,0 +1,263 @@
+/**
+ * Memory System Tests
+ * P3.3: Semantic Memory Database
+ */
+
+const memorySystem = require('../../agentic/memory-system')
+const fs = require('fs').promises
+const path = require('path')
+const os = require('os')
+
+// Generate unique project ID for each test run
+let testCounter = 0
+const getTestProjectId = () => `test-memory-${Date.now()}-${++testCounter}`
+
+describe('MemorySystem P3.3', () => {
+  let TEST_PROJECT_ID
+
+  beforeEach(() => {
+    // Use unique project ID for each test to avoid data leakage
+    TEST_PROJECT_ID = getTestProjectId()
+    // Reset internal state
+    memorySystem._memories = null
+    memorySystem._memoriesLoaded = false
+    memorySystem._patterns = null
+    memorySystem._patternsLoaded = false
+    memorySystem._sessionMemory.clear()
+  })
+
+  describe('createMemory', () => {
+    it('should create a memory with tags', async () => {
+      const memoryId = await memorySystem.createMemory(TEST_PROJECT_ID, {
+        title: 'Test Memory',
+        content: 'This is test content',
+        tags: ['code_style', 'naming_convention'],
+        userTriggered: true
+      })
+
+      expect(memoryId).toMatch(/^mem_/)
+
+      const memories = await memorySystem.getAllMemories(TEST_PROJECT_ID)
+      expect(memories.length).toBe(1)
+      expect(memories[0].title).toBe('Test Memory')
+      expect(memories[0].tags).toContain('code_style')
+      expect(memories[0].userTriggered).toBe(true)
+    })
+  })
+
+  describe('updateMemory', () => {
+    it('should update memory content and tags', async () => {
+      const memoryId = await memorySystem.createMemory(TEST_PROJECT_ID, {
+        title: 'Original Title',
+        content: 'Original content',
+        tags: ['code_style']
+      })
+
+      const updated = await memorySystem.updateMemory(TEST_PROJECT_ID, memoryId, {
+        title: 'Updated Title',
+        content: 'Updated content',
+        tags: ['naming_convention', 'architecture']
+      })
+
+      expect(updated).toBe(true)
+
+      const memories = await memorySystem.getAllMemories(TEST_PROJECT_ID)
+      const memory = memories.find(m => m.id === memoryId)
+
+      expect(memory.title).toBe('Updated Title')
+      expect(memory.content).toBe('Updated content')
+      expect(memory.tags).toContain('architecture')
+      expect(memory.tags).not.toContain('code_style')
+    })
+
+    it('should return false for non-existent memory', async () => {
+      const result = await memorySystem.updateMemory(TEST_PROJECT_ID, 'non_existent_id', {
+        title: 'New Title'
+      })
+      expect(result).toBe(false)
+    })
+  })
+
+  describe('deleteMemory', () => {
+    it('should delete a memory', async () => {
+      const memoryId = await memorySystem.createMemory(TEST_PROJECT_ID, {
+        title: 'To Delete',
+        content: 'Will be deleted',
+        tags: ['test']
+      })
+
+      const deleted = await memorySystem.deleteMemory(TEST_PROJECT_ID, memoryId)
+      expect(deleted).toBe(true)
+
+      const memories = await memorySystem.getAllMemories(TEST_PROJECT_ID)
+      expect(memories.find(m => m.id === memoryId)).toBeUndefined()
+    })
+  })
+
+  describe('findByTags', () => {
+    beforeEach(async () => {
+      // Create test memories
+      await memorySystem.createMemory(TEST_PROJECT_ID, {
+        title: 'Memory 1',
+        content: 'Content 1',
+        tags: ['code_style', 'naming_convention']
+      })
+      await memorySystem.createMemory(TEST_PROJECT_ID, {
+        title: 'Memory 2',
+        content: 'Content 2',
+        tags: ['architecture', 'naming_convention']
+      })
+      await memorySystem.createMemory(TEST_PROJECT_ID, {
+        title: 'Memory 3',
+        content: 'Content 3',
+        tags: ['commit_style']
+      })
+    })
+
+    it('should find memories with ANY tag (OR)', async () => {
+      const results = await memorySystem.findByTags(TEST_PROJECT_ID, ['code_style', 'architecture'], false)
+      expect(results.length).toBe(2)
+    })
+
+    it('should find memories with ALL tags (AND)', async () => {
+      const results = await memorySystem.findByTags(TEST_PROJECT_ID, ['naming_convention', 'architecture'], true)
+      expect(results.length).toBe(1)
+      expect(results[0].title).toBe('Memory 2')
+    })
+  })
+
+  describe('searchMemories', () => {
+    beforeEach(async () => {
+      await memorySystem.createMemory(TEST_PROJECT_ID, {
+        title: 'React Hooks Pattern',
+        content: 'Use custom hooks for reusable logic',
+        tags: ['code_style']
+      })
+      await memorySystem.createMemory(TEST_PROJECT_ID, {
+        title: 'API Design',
+        content: 'REST endpoints follow /api/v1 pattern',
+        tags: ['architecture']
+      })
+    })
+
+    it('should search by title', async () => {
+      const results = await memorySystem.searchMemories(TEST_PROJECT_ID, 'React')
+      expect(results.length).toBe(1)
+      expect(results[0].title).toContain('React')
+    })
+
+    it('should search by content', async () => {
+      const results = await memorySystem.searchMemories(TEST_PROJECT_ID, 'endpoints')
+      expect(results.length).toBe(1)
+      expect(results[0].content).toContain('endpoints')
+    })
+
+    it('should be case insensitive', async () => {
+      const results = await memorySystem.searchMemories(TEST_PROJECT_ID, 'HOOKS')
+      expect(results.length).toBe(1)
+    })
+  })
+
+  describe('getRelevantMemories', () => {
+    beforeEach(async () => {
+      // Create memories with different relevance
+      await memorySystem.createMemory(TEST_PROJECT_ID, {
+        title: 'Commit Style',
+        content: 'Use conventional commits',
+        tags: ['commit_style', 'ship_workflow'],
+        userTriggered: true
+      })
+      await memorySystem.createMemory(TEST_PROJECT_ID, {
+        title: 'Test Behavior',
+        content: 'Run tests before shipping',
+        tags: ['test_behavior', 'ship_workflow']
+      })
+      await memorySystem.createMemory(TEST_PROJECT_ID, {
+        title: 'Code Style',
+        content: 'Use TypeScript strict mode',
+        tags: ['code_style']
+      })
+    })
+
+    it('should return memories relevant to ship command', async () => {
+      const context = { commandName: 'ship', params: {} }
+      const results = await memorySystem.getRelevantMemories(TEST_PROJECT_ID, context, 5)
+
+      expect(results.length).toBeGreaterThan(0)
+      // Ship command should prioritize commit_style and ship_workflow tags
+      const hasRelevantTags = results.some(m =>
+        m.tags.includes('commit_style') || m.tags.includes('ship_workflow')
+      )
+      expect(hasRelevantTags).toBe(true)
+    })
+
+    it('should prioritize user triggered memories', async () => {
+      const context = { commandName: 'ship', params: {} }
+      const results = await memorySystem.getRelevantMemories(TEST_PROJECT_ID, context, 5)
+
+      // User triggered should be ranked higher
+      const userTriggeredIndex = results.findIndex(m => m.userTriggered)
+      expect(userTriggeredIndex).toBeLessThanOrEqual(1) // Should be in top 2
+    })
+
+    it('should limit results', async () => {
+      const context = { commandName: 'ship', params: {} }
+      const results = await memorySystem.getRelevantMemories(TEST_PROJECT_ID, context, 1)
+      expect(results.length).toBeLessThanOrEqual(1)
+    })
+  })
+
+  describe('autoRemember', () => {
+    it('should create memory from user decision', async () => {
+      await memorySystem.autoRemember(TEST_PROJECT_ID, 'commit_footer', 'prjct', 'User chose prjct footer')
+
+      const memories = await memorySystem.getAllMemories(TEST_PROJECT_ID)
+      expect(memories.length).toBe(1)
+      expect(memories[0].content).toContain('commit_footer: prjct')
+      expect(memories[0].tags).toContain('commit_style')
+      expect(memories[0].userTriggered).toBe(true)
+    })
+
+    it('should update existing memory instead of creating duplicate', async () => {
+      await memorySystem.autoRemember(TEST_PROJECT_ID, 'commit_footer', 'prjct', 'First choice')
+      await memorySystem.autoRemember(TEST_PROJECT_ID, 'commit_footer', 'claude', 'Changed mind')
+
+      const memories = await memorySystem.getAllMemories(TEST_PROJECT_ID)
+      expect(memories.length).toBe(1)
+      expect(memories[0].content).toContain('commit_footer: claude')
+    })
+  })
+
+  describe('getMemoryStats', () => {
+    it('should return memory statistics', async () => {
+      await memorySystem.createMemory(TEST_PROJECT_ID, {
+        title: 'Memory 1',
+        content: 'Content 1',
+        tags: ['code_style'],
+        userTriggered: true
+      })
+      await memorySystem.createMemory(TEST_PROJECT_ID, {
+        title: 'Memory 2',
+        content: 'Content 2',
+        tags: ['code_style', 'architecture']
+      })
+
+      const stats = await memorySystem.getMemoryStats(TEST_PROJECT_ID)
+
+      expect(stats.totalMemories).toBe(2)
+      expect(stats.userTriggered).toBe(1)
+      expect(stats.tagCounts.code_style).toBe(2)
+      expect(stats.tagCounts.architecture).toBe(1)
+    })
+  })
+
+  // Cleanup test directories after each test
+  afterEach(async () => {
+    try {
+      const testPath = path.join(os.homedir(), '.prjct-cli', 'projects', TEST_PROJECT_ID)
+      await fs.rm(testPath, { recursive: true, force: true })
+    } catch {
+      // Ignore cleanup errors
+    }
+  })
+})

package/core/__tests__/agentic/plan-mode.test.js

@@ -0,0 +1,336 @@
+/**
+ * Plan Mode Tests
+ * P3.4: Plan Mode + Approval Flow
+ */
+
+const planMode = require('../../agentic/plan-mode')
+const { PLAN_STATUS, PLAN_REQUIRED_COMMANDS, DESTRUCTIVE_COMMANDS, PLANNING_TOOLS } = require('../../agentic/plan-mode')
+
+describe('PlanMode P3.4', () => {
+  const TEST_PROJECT_ID = 'test-plan-mode'
+
+  beforeEach(() => {
+    // Clear any active plans
+    planMode.activePlans.clear()
+  })
+
+  describe('requiresPlanning', () => {
+    it('should return true for feature command', () => {
+      expect(planMode.requiresPlanning('feature')).toBe(true)
+    })
+
+    it('should return true for spec command', () => {
+      expect(planMode.requiresPlanning('spec')).toBe(true)
+    })
+
+    it('should return false for now command', () => {
+      expect(planMode.requiresPlanning('now')).toBe(false)
+    })
+
+    it('should return false for done command', () => {
+      expect(planMode.requiresPlanning('done')).toBe(false)
+    })
+  })
+
+  describe('isDestructive', () => {
+    it('should return true for ship command', () => {
+      expect(planMode.isDestructive('ship')).toBe(true)
+    })
+
+    it('should return true for cleanup command', () => {
+      expect(planMode.isDestructive('cleanup')).toBe(true)
+    })
+
+    it('should return false for feature command', () => {
+      expect(planMode.isDestructive('feature')).toBe(false)
+    })
+  })
+
+  describe('isToolAllowedInPlanning', () => {
+    it('should allow Read in planning mode', () => {
+      expect(planMode.isToolAllowedInPlanning('Read')).toBe(true)
+    })
+
+    it('should allow Glob in planning mode', () => {
+      expect(planMode.isToolAllowedInPlanning('Glob')).toBe(true)
+    })
+
+    it('should not allow Write in planning mode', () => {
+      expect(planMode.isToolAllowedInPlanning('Write')).toBe(false)
+    })
+
+    it('should not allow Bash in planning mode', () => {
+      expect(planMode.isToolAllowedInPlanning('Bash')).toBe(false)
+    })
+  })
+
+  describe('getAllowedTools', () => {
+    it('should filter to read-only tools in planning mode', () => {
+      const templateTools = ['Read', 'Write', 'Glob', 'Bash', 'Grep']
+      const allowed = planMode.getAllowedTools(true, templateTools)
+
+      expect(allowed).toContain('Read')
+      expect(allowed).toContain('Glob')
+      expect(allowed).toContain('Grep')
+      expect(allowed).not.toContain('Write')
+      expect(allowed).not.toContain('Bash')
+    })
+
+    it('should return all template tools when not in planning mode', () => {
+      const templateTools = ['Read', 'Write', 'Glob', 'Bash']
+      const allowed = planMode.getAllowedTools(false, templateTools)
+
+      expect(allowed).toEqual(templateTools)
+    })
+  })
+
+  describe('startPlanning', () => {
+    it('should create a new plan with correct initial state', () => {
+      const plan = planMode.startPlanning(TEST_PROJECT_ID, 'feature', { description: 'Add dark mode' })
+
+      expect(plan.id).toMatch(/^plan_/)
+      expect(plan.projectId).toBe(TEST_PROJECT_ID)
+      expect(plan.command).toBe('feature')
+      expect(plan.status).toBe(PLAN_STATUS.GATHERING)
+      expect(plan.gatheredInfo).toEqual([])
+    })
+
+    it('should store plan in activePlans', () => {
+      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
+
+      expect(planMode.getActivePlan(TEST_PROJECT_ID)).not.toBeNull()
+    })
+  })
+
+  describe('isInPlanningMode', () => {
+    it('should return true when gathering info', () => {
+      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
+
+      expect(planMode.isInPlanningMode(TEST_PROJECT_ID)).toBe(true)
+    })
+
+    it('should return true when pending approval', () => {
+      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
+      planMode.proposePlan(TEST_PROJECT_ID, { summary: 'Test', steps: [] })
+
+      expect(planMode.isInPlanningMode(TEST_PROJECT_ID)).toBe(true)
+    })
+
+    it('should return false when no active plan', () => {
+      expect(planMode.isInPlanningMode('non-existent-project')).toBe(false)
+    })
+
+    it('should return false when plan is executing', () => {
+      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
+      planMode.proposePlan(TEST_PROJECT_ID, { summary: 'Test', steps: [{ description: 'Step 1' }] })
+      planMode.approvePlan(TEST_PROJECT_ID)
+      planMode.startExecution(TEST_PROJECT_ID)
+
+      expect(planMode.isInPlanningMode(TEST_PROJECT_ID)).toBe(false)
+    })
+  })
+
+  describe('recordGatheredInfo', () => {
+    it('should add info to gatheredInfo array', () => {
+      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
+      planMode.recordGatheredInfo(TEST_PROJECT_ID, { type: 'file', source: 'src/index.js', data: 'content' })
+
+      const plan = planMode.getActivePlan(TEST_PROJECT_ID)
+      expect(plan.gatheredInfo.length).toBe(1)
+      expect(plan.gatheredInfo[0].type).toBe('file')
+    })
+  })
+
+  describe('proposePlan', () => {
+    it('should set status to pending approval', () => {
+      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
+      planMode.proposePlan(TEST_PROJECT_ID, {
+        summary: 'Add dark mode feature',
+        approach: 'CSS variables with theme context',
+        steps: [{ description: 'Create theme context' }, { description: 'Add toggle' }]
+      })
+
+      const plan = planMode.getActivePlan(TEST_PROJECT_ID)
+      expect(plan.status).toBe(PLAN_STATUS.PENDING_APPROVAL)
+    })
+
+    it('should return formatted plan for display', () => {
+      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
+      const formatted = planMode.proposePlan(TEST_PROJECT_ID, {
+        summary: 'Test plan',
+        approach: 'Test approach',
+        steps: [{ description: 'Step 1' }]
+      })
+
+      expect(formatted.summary).toBe('Test plan')
+      expect(formatted.approach).toBe('Test approach')
+      expect(formatted.requiresConfirmation).toBe(true)
+    })
+  })
+
+  describe('approvePlan', () => {
+    it('should change status to approved', () => {
+      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
+      planMode.proposePlan(TEST_PROJECT_ID, { steps: [{ description: 'Step 1' }] })
+      const result = planMode.approvePlan(TEST_PROJECT_ID)
+
+      expect(result.approved).toBe(true)
+      const plan = planMode.getActivePlan(TEST_PROJECT_ID)
+      expect(plan.status).toBe(PLAN_STATUS.APPROVED)
+    })
+
+    it('should convert proposed steps to executable steps', () => {
+      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
+      planMode.proposePlan(TEST_PROJECT_ID, {
+        steps: [{ description: 'Step 1' }, { description: 'Step 2' }]
+      })
+      const result = planMode.approvePlan(TEST_PROJECT_ID)
+
+      expect(result.steps.length).toBe(2)
+      expect(result.steps[0].status).toBe('pending')
+    })
+
+    it('should return null if not pending approval', () => {
+      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
+      // Not proposed yet, so should return null
+      const result = planMode.approvePlan(TEST_PROJECT_ID)
+
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('rejectPlan', () => {
+    it('should mark plan as rejected', () => {
+      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
+      planMode.proposePlan(TEST_PROJECT_ID, { steps: [] })
+      const result = planMode.rejectPlan(TEST_PROJECT_ID, 'Not the right approach')
+
+      expect(result.rejected).toBe(true)
+      expect(result.reason).toBe('Not the right approach')
+    })
+
+    it('should clear active plan after rejection', () => {
+      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
+      planMode.proposePlan(TEST_PROJECT_ID, { steps: [] })
+      planMode.rejectPlan(TEST_PROJECT_ID)
+
+      expect(planMode.getActivePlan(TEST_PROJECT_ID)).toBeNull()
+    })
+  })
+
+  describe('execution flow', () => {
+    beforeEach(() => {
+      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
+      planMode.proposePlan(TEST_PROJECT_ID, {
+        steps: [
+          { description: 'Step 1', tool: 'Write' },
+          { description: 'Step 2', tool: 'Bash' }
+        ]
+      })
+      planMode.approvePlan(TEST_PROJECT_ID)
+    })
+
+    it('should start execution and return first step', () => {
+      const step = planMode.startExecution(TEST_PROJECT_ID)
+
+      expect(step.stepNumber).toBe(1)
+      expect(step.totalSteps).toBe(2)
+      expect(step.progress).toBe(0)
+    })
+
+    it('should advance to next step on completion', () => {
+      planMode.startExecution(TEST_PROJECT_ID)
+      const nextStep = planMode.completeStep(TEST_PROJECT_ID, { success: true })
+
+      expect(nextStep.stepNumber).toBe(2)
+      expect(nextStep.progress).toBe(50)
+    })
+
+    it('should complete plan when all steps done', () => {
+      planMode.startExecution(TEST_PROJECT_ID)
+      planMode.completeStep(TEST_PROJECT_ID)
+      const result = planMode.completeStep(TEST_PROJECT_ID)
+
+      // When all steps complete, getNextStep returns null and completePlan is called
+      expect(result).toBeNull()
+      expect(planMode.getActivePlan(TEST_PROJECT_ID)).toBeNull()
+    })
+  })
+
+  describe('abortPlan', () => {
+    it('should abort and clear active plan', () => {
+      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
+      planMode.proposePlan(TEST_PROJECT_ID, { steps: [{ description: 'Step 1' }] })
+      planMode.approvePlan(TEST_PROJECT_ID)
+      planMode.startExecution(TEST_PROJECT_ID)
+
+      const result = planMode.abortPlan(TEST_PROJECT_ID, 'User cancelled')
+
+      expect(result.aborted).toBe(true)
+      expect(result.reason).toBe('User cancelled')
+      expect(planMode.getActivePlan(TEST_PROJECT_ID)).toBeNull()
+    })
+  })
+
+  describe('generateApprovalPrompt', () => {
+    it('should generate ship approval prompt', () => {
+      const prompt = planMode.generateApprovalPrompt('ship', {
+        branch: 'feature/dark-mode',
+        changedFiles: ['a.js', 'b.js'],
+        commitMessage: 'Add dark mode'
+      })
+
+      expect(prompt.title).toBe('Ship Confirmation')
+      expect(prompt.details).toContain('Branch: feature/dark-mode')
+      expect(prompt.options.length).toBe(3)
+    })
+
+    it('should generate cleanup approval prompt', () => {
+      const prompt = planMode.generateApprovalPrompt('cleanup', {
+        filesToDelete: ['temp.js'],
+        linesOfCode: 50
+      })
+
+      expect(prompt.title).toBe('Cleanup Confirmation')
+      expect(prompt.message).toContain('delete')
+    })
+
+    it('should generate default prompt for unknown commands', () => {
+      const prompt = planMode.generateApprovalPrompt('unknown', {})
+
+      expect(prompt.title).toBe('Confirmation Required')
+      expect(prompt.options.length).toBe(2)
+    })
+  })
+
+  describe('formatStatus', () => {
+    it('should format gathering status', () => {
+      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
+      const status = planMode.formatStatus(TEST_PROJECT_ID)
+
+      expect(status).toContain('🔍')
+      expect(status).toContain('feature')
+      expect(status).toContain('gathering')
+    })
+
+    it('should show progress during execution', () => {
+      planMode.startPlanning(TEST_PROJECT_ID, 'feature', {})
+      planMode.proposePlan(TEST_PROJECT_ID, {
+        steps: [{ description: 'Step 1' }, { description: 'Step 2' }]
+      })
+      planMode.approvePlan(TEST_PROJECT_ID)
+      planMode.startExecution(TEST_PROJECT_ID)
+
+      const status = planMode.formatStatus(TEST_PROJECT_ID)
+
+      expect(status).toContain('⚡')
+      expect(status).toContain('Progress')
+    })
+
+    it('should return message for no active plan', () => {
+      const status = planMode.formatStatus('non-existent')
+
+      expect(status).toBe('No active plan')
+    })
+  })
+})