prjct-cli 0.31.0 → 0.34.0

package/CHANGELOG.md

@@ -1,5 +1,188 @@
 # Changelog
 
+## [0.34.0] - 2026-01-15
+
+### Feature: Agentic Orchestrator + MCP Auto-Install
+
+Major release with intelligent task routing and simplified integration setup.
+
+#### Orchestrator Agent (NEW)
+
+Auto-routing system for tasks to the right agents and skills:
+
+- **Domain Detection**: Analyzes task keywords to detect domains (frontend, backend, database, etc.)
+- **Agent Loading**: Automatically loads relevant agents from `{globalPath}/agents/`
+- **Skill Invocation**: Invokes skills from `~/.claude/skills/` based on task context
+- **Multi-Domain Coordination**: Handles tasks spanning multiple domains with proper execution order
+
+**Usage**: Orchestrator runs automatically for task-related commands (`p. task`, `p. done`, `p. ship`, etc.)
+
+#### MCP Server Auto-Install
+
+All integrations now auto-install their MCP servers:
+
+- **Linear**: Auto-installs `mcp-remote` for Linear API
+- **JIRA**: Auto-installs Atlassian MCP server
+- **GitHub**: Auto-installs GitHub MCP server with token validation
+- **Monday.com**: Auto-installs Monday MCP server
+
+No more manual `~/.claude/settings.json` editing - just run `p. linear setup` and it handles everything.
+
+#### Individual Command Skills
+
+All 37 prjct commands now available as individual Claude Code skills:
+
+- `/p.task` - Start a task
+- `/p.sync` - Sync project
+- `/p.linear` - Linear integration
+- Plus 34 more commands
+
+#### agentskills.io Integration
+
+Skills are now discovered from the official agentskills.io ecosystem:
+
+- Skills from `anthropics/skills` GitHub repo
+- Proper SKILL.md format with YAML frontmatter
+- Agent-to-skill mapping in `templates/config/skill-mappings.json`
+
+**Files Changed:**
+- `templates/agentic/orchestrator.md` (NEW)
+- `templates/commands/p.md` - Orchestrator integration
+- `templates/commands/task.md` - Orchestrator context usage
+- `templates/commands/linear.md` - MCP auto-install
+- `templates/commands/jira.md` - MCP auto-install
+- `templates/commands/github.md` - MCP auto-install
+- `templates/commands/monday.md` - MCP auto-install
+- `templates/config/skill-mappings.json` - agentskills.io sources
+- `scripts/postinstall.js` - Individual command installation
+
+**Removed (deprecated):**
+- `templates/commands/feature.md`
+- `templates/commands/now.md`
+- `templates/commands/dashboard.md`
+- `templates/commands/suggest.md`
+- `templates/commands/ask.md`
+
+---
+
+## [0.33.5] - 2026-01-13
+
+### Fix: Type Safety Improvements (PRJ-54)
+
+Remove unsafe `as unknown` type casts with proper TypeScript interfaces.
+
+**Changes:**
+- `GroundTruthContext` now uses `ContextPaths` directly
+- `chain-of-thought.ts` uses `Pick<ProjectContext, ...>` type alias
+- `command-executor.ts` uses `PromptContext` instead of `Record<string, unknown>`
+
+---
+
+## [0.33.4] - 2026-01-13
+
+### Refactor: Error Type Differentiation Phase 3 (PRJ-61)
+
+**Final phase** - Complete error differentiation across all 116 remaining catch blocks in 52 files.
+
+**Pattern Applied:**
+- `isNotFoundError()` for expected ENOENT errors
+- `instanceof SyntaxError` for JSON parse errors
+- `_error` capture for intentional catch-all blocks (network, git, etc.)
+- Unexpected errors propagate with `throw error`
+
+**Key Files Fixed:**
+- `core/storage/storage.ts` - Storage read/exists operations
+- `core/commands/shipping.ts` - Ship workflow error handling
+- `core/session/task-session-manager.ts` - Session management
+- `core/commands/cleanup.ts` - Cleanup operations
+- `core/agentic/context-builder.ts` - Context building
+- Plus 47 more files
+
+**Stats:**
+- Catches fixed this phase: 116
+- Total fixed (Phase 1+2+3): 185
+- Remaining: 0 empty catches
+
+---
+
+## [0.33.3] - 2026-01-13
+
+### Refactor: Error Type Differentiation Phase 2 (PRJ-60)
+
+**Continuation of PRJ-51** - Differentiate error types in 3 more files (14 catch blocks):
+
+**Files Modified:**
+- `core/domain/snapshot-manager.ts` - 6 catches (fs.access, fs.readFile, fs.unlink, JSON.parse)
+- `core/server/routes-extended.ts` - 2 catches (readJsonFile, writeJsonFile helpers)
+- `core/infrastructure/setup.ts` - 6 catches (migration, settings parsing, status line)
+
+**Pattern Applied:**
+- ENOENT errors → handled gracefully (expected for missing files)
+- SyntaxError → handled gracefully (expected for malformed JSON)
+- Other errors → propagated or logged (unexpected)
+
+**Stats:**
+- Catches fixed: 14
+- Total fixed (Phase 1+2): 69
+- Remaining: ~211 catches in 63 files
+
+---
+
+## [0.33.2] - 2026-01-13
+
+### Refactor: Error Type Differentiation (PRJ-51)
+
+**Problem:** 280 catch blocks across 69 files used empty `catch {}` which swallowed all errors without differentiating between expected (ENOENT) and unexpected errors.
+
+**Solution:** Phase 1 implementation - differentiate error types in 3 priority files (55 catch blocks):
+
+**Pattern Applied:**
+```typescript
+// Before
+} catch { return null }
+
+// After
+} catch (error) {
+  if (isNotFoundError(error)) return null      // Expected: file doesn't exist
+  if (error instanceof SyntaxError) return null // Expected: invalid JSON
+  throw error                                   // Unexpected: propagate
+}
+```
+
+**Files Modified:**
+- `core/agentic/ground-truth.ts` - 21 catches (verification functions)
+- `core/domain/analyzer.ts` - 18 catches (codebase analysis)
+- `core/infrastructure/command-installer.ts` - 16 catches (command management)
+
+**Tests Added:**
+- `core/__tests__/types/fs.test.ts` - 15 new tests for error utilities
+
+**Stats:**
+- Tests: 137 → 152 (+15)
+- Catches fixed: 55
+- Files: 4 (3 refactored + 1 test)
+
+---
+
+## [0.33.1] - 2026-01-13
+
+### Refactor: Code Quality Improvements
+
+**PRJ-58: Consolidate hardcoded paths to pathManager**
+- Added `getClaudeDir()`, `getClaudeCommandsDir()`, `getClaudeSettingsPath()` to pathManager
+- Refactored 6 files to use centralized path methods instead of `os.homedir()` concatenation
+- Files: `compaction.ts`, `generator.ts`, `routes-extended.ts`, `routes.ts`, `auth-config.ts`, `setup.ts`
+
+**PRJ-57: Simplify logger level detection**
+- Use `Set` for truthy values instead of multiple OR conditions
+- Remove redundant `'prjct'` equality check (covered by `includes`)
+- Use nullish coalescing (`??`) instead of ternary
+- Pre-compute level name to avoid runtime lookup
+- Add `createLogMethod()` factory to reduce repetition
+- File: `core/utils/logger.ts`
+
+---
+
 ## [0.30.3] - 2026-01-13
 
 ### Fix: Enrichment Not Enabled by Default

package/CLAUDE.md

@@ -91,6 +91,7 @@ User Action → Storage (JSON) → Context (MD) → Sync Events
 
 ## COMMANDS
 
+### Core Workflow
 | Trigger | Purpose |
 |---------|---------|
 | `p. init` | Initialize project with deep analysis |
@@ -102,11 +103,51 @@ User Action → Storage (JSON) → Context (MD) → Sync Events
 | `p. resume` | Resume paused task |
 | `p. bug <desc>` | Report bug with auto-priority |
 
+### Issue Tracker Integrations
+| Trigger | Purpose |
+|---------|---------|
+| `p. linear` | Linear issues (OAuth via MCP) |
+| `p. jira` | JIRA issues (OAuth/SSO via MCP) |
+| `p. github` | GitHub Issues (token via MCP) |
+| `p. monday` | Monday.com boards (OAuth via MCP) |
+| `p. enrich <ID>` | **AI-powered ticket enrichment** |
+
+### Ticket Enrichment (`p. enrich`)
+
+Transform vague PM tickets into technical PRDs:
+
+```
+PM creates: "Add user auth"
+            ↓
+p. enrich PRJ-59
+            ↓
+Architect analyzes codebase:
+- Similar implementations found
+- 5 files affected
+- OAuth2 approach recommended
+- 8 story points (not PM's guess of 2)
+            ↓
+Publishes PRD to tracker:
+- Technical approach
+- Acceptance criteria
+- LLM-ready prompt (for any AI tool)
+```
+
+**Subcommands:**
+- `p. enrich <ID>` - Enrich specific ticket
+- `p. enrich setup` - Configure team preferences (estimation, output)
+- `p. enrich batch` - Enrich all assigned tickets (backlog grooming)
+
 ### Workflow
 ```
 p. sync → p. task "description" → [work] → p. done → p. ship
 ```
 
+### With Issue Tracker
+```
+p. linear → p. enrich PRJ-59 → p. linear start PRJ-59 → [work] → p. done → p. ship
+```
+
 ---
 
 ## INTELLIGENT BEHAVIOR

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

@@ -253,7 +253,7 @@ describe('MemorySystem P3.3', () => {
     try {
       const testPath = pathManager.getGlobalProjectPath(TEST_PROJECT_ID)
       await fs.rm(testPath, { recursive: true, force: true })
-    } catch {
+    } catch (_error) {
       // Ignore cleanup errors
     }
   })
@@ -261,7 +261,7 @@ describe('MemorySystem P3.3', () => {
   afterAll(async () => {
     try {
       await fs.rm(TEST_GLOBAL_BASE_DIR, { recursive: true, force: true })
-    } catch {
+    } catch (_error) {
       // Ignore cleanup errors
     }
   })

package/core/__tests__/types/fs.test.ts

@@ -0,0 +1,125 @@
+/**
+ * FS Types Tests
+ * Tests for file system error utilities
+ */
+
+import { describe, it, expect } from 'bun:test'
+import {
+  isNotFoundError,
+  isPermissionError,
+  isDirNotEmptyError,
+  isFileExistsError,
+  isNodeError,
+} from '../../types/fs'
+
+describe('FS Error Utilities', () => {
+  describe('isNotFoundError', () => {
+    it('should return true for ENOENT error', () => {
+      const error = new Error('File not found') as NodeJS.ErrnoException
+      error.code = 'ENOENT'
+      expect(isNotFoundError(error)).toBe(true)
+    })
+
+    it('should return false for other error codes', () => {
+      const error = new Error('Permission denied') as NodeJS.ErrnoException
+      error.code = 'EACCES'
+      expect(isNotFoundError(error)).toBe(false)
+    })
+
+    it('should return false for errors without code', () => {
+      const error = new Error('Generic error')
+      expect(isNotFoundError(error)).toBe(false)
+    })
+
+    it('should return false for non-error values', () => {
+      expect(isNotFoundError(null)).toBe(false)
+      expect(isNotFoundError(undefined)).toBe(false)
+      expect(isNotFoundError('string')).toBe(false)
+    })
+  })
+
+  describe('isPermissionError', () => {
+    it('should return true for EACCES error', () => {
+      const error = new Error('Permission denied') as NodeJS.ErrnoException
+      error.code = 'EACCES'
+      expect(isPermissionError(error)).toBe(true)
+    })
+
+    it('should return true for EPERM error', () => {
+      const error = new Error('Operation not permitted') as NodeJS.ErrnoException
+      error.code = 'EPERM'
+      expect(isPermissionError(error)).toBe(true)
+    })
+
+    it('should return false for other error codes', () => {
+      const error = new Error('File not found') as NodeJS.ErrnoException
+      error.code = 'ENOENT'
+      expect(isPermissionError(error)).toBe(false)
+    })
+  })
+
+  describe('isDirNotEmptyError', () => {
+    it('should return true for ENOTEMPTY error', () => {
+      const error = new Error('Directory not empty') as NodeJS.ErrnoException
+      error.code = 'ENOTEMPTY'
+      expect(isDirNotEmptyError(error)).toBe(true)
+    })
+
+    it('should return false for other error codes', () => {
+      const error = new Error('File not found') as NodeJS.ErrnoException
+      error.code = 'ENOENT'
+      expect(isDirNotEmptyError(error)).toBe(false)
+    })
+  })
+
+  describe('isFileExistsError', () => {
+    it('should return true for EEXIST error', () => {
+      const error = new Error('File exists') as NodeJS.ErrnoException
+      error.code = 'EEXIST'
+      expect(isFileExistsError(error)).toBe(true)
+    })
+
+    it('should return false for other error codes', () => {
+      const error = new Error('File not found') as NodeJS.ErrnoException
+      error.code = 'ENOENT'
+      expect(isFileExistsError(error)).toBe(false)
+    })
+  })
+
+  describe('isNodeError', () => {
+    it('should return true for Error with code property', () => {
+      const error = new Error('File not found') as NodeJS.ErrnoException
+      error.code = 'ENOENT'
+      expect(isNodeError(error)).toBe(true)
+    })
+
+    it('should return false for Error without code property', () => {
+      const error = new Error('Generic error')
+      expect(isNodeError(error)).toBe(false)
+    })
+
+    it('should return false for non-Error values', () => {
+      expect(isNodeError(null)).toBe(false)
+      expect(isNodeError({ code: 'ENOENT' })).toBe(false) // Not an Error instance
+    })
+  })
+
+  describe('SyntaxError handling pattern', () => {
+    it('should differentiate SyntaxError from fs errors', () => {
+      const syntaxError = new SyntaxError('Unexpected token')
+      const fsError = new Error('File not found') as NodeJS.ErrnoException
+      fsError.code = 'ENOENT'
+
+      // Pattern used in code
+      const handleError = (error: unknown): string => {
+        if (isNotFoundError(error)) return 'not-found'
+        if (error instanceof SyntaxError) return 'parse-error'
+        return 'other'
+      }
+
+      expect(handleError(fsError)).toBe('not-found')
+      expect(handleError(syntaxError)).toBe('parse-error')
+      expect(handleError(new Error('Other'))).toBe('other')
+    })
+  })
+})

package/core/agentic/agent-router.ts

@@ -15,6 +15,7 @@ import fs from 'fs/promises'
 import path from 'path'
 import configManager from '../infrastructure/config-manager'
 import pathManager from '../infrastructure/path-manager'
+import { isNotFoundError } from '../types/fs'
 import type { Agent, AssignmentContext } from '../types'
 
 // Re-export types for convenience
@@ -57,7 +58,11 @@ class AgentRouter {
       }
 
       return agents
-    } catch {
+    } catch (error) {
+      // Agents directory doesn't exist yet - expected for new projects
+      if (!isNotFoundError(error)) {
+        console.error(`Agent loading error: ${(error as Error).message}`)
+      }
       return []
     }
   }
@@ -80,7 +85,11 @@ class AgentRouter {
       const filePath = path.join(this.agentsPath, `${name}.md`)
       const content = await fs.readFile(filePath, 'utf-8')
       return { name, content }
-    } catch {
+    } catch (error) {
+      // Agent file doesn't exist - expected
+      if (!isNotFoundError(error)) {
+        console.error(`Agent load error: ${(error as Error).message}`)
+      }
       return null
     }
   }
@@ -130,8 +139,11 @@ class AgentRouter {
         }) + '\n'
 
       await fs.appendFile(logPath, entry)
-    } catch {
-      // Silent fail for logging
+    } catch (error) {
+      // Non-critical - log unexpected errors but don't fail
+      if (!isNotFoundError(error)) {
+        console.error(`Agent usage log error: ${(error as Error).message}`)
+      }
     }
   }
 }

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

@@ -6,19 +6,11 @@
  * @version 1.0.0
  */
 
-interface Context {
-  projectId?: string | null
-  projectPath: string
-  params: Record<string, unknown>
-}
+import type { ProjectContext, ContextState } from '../types'
 
-interface State {
-  now?: string | null
-  next?: string | null
-  shipped?: string | null
-  analysis?: string | null
-  [key: string]: unknown
-}
+// Type aliases for compatibility with ProjectContext from contextBuilder.build()
+type Context = Pick<ProjectContext, 'projectId' | 'projectPath' | 'params'>
+type State = ContextState
 
 interface ReasoningStep {
   step: string

package/core/agentic/command-executor.ts

@@ -24,6 +24,7 @@ import type {
   SimpleExecutionResult,
   ExecutionToolsFn,
   ApprovalContext,
+  PromptContext,
 } from '../types'
 
 // =============================================================================
@@ -42,7 +43,7 @@ export function signalStart(commandName: string): void {
       fs.mkdirSync(dir, { recursive: true })
     }
     fs.writeFileSync(RUNNING_FILE, `/p:${commandName}`)
-  } catch {
+  } catch (_error) {
     // Silently ignore - status line is optional
   }
 }
@@ -55,7 +56,7 @@ export function signalEnd(): void {
     if (fs.existsSync(RUNNING_FILE)) {
       fs.unlinkSync(RUNNING_FILE)
     }
-  } catch {
+  } catch (_error) {
     // Silently ignore - status line is optional
   }
 }
@@ -132,7 +133,7 @@ export class CommandExecutor {
         const preState = await contextBuilder.loadStateForCommand(metadataContext, commandName)
         groundTruthResult = await groundTruth.verify(
           commandName,
-          metadataContext as unknown as Parameters<typeof groundTruth.verify>[1],
+          metadataContext,
           preState
         )
 
@@ -148,8 +149,8 @@ export class CommandExecutor {
         const reasoningState = await contextBuilder.loadStateForCommand(metadataContext, commandName)
         reasoning = await chainOfThought.reason(
           commandName,
-          metadataContext as unknown as Parameters<typeof chainOfThought.reason>[1],
-          reasoningState as Parameters<typeof chainOfThought.reason>[2]
+          metadataContext,
+          reasoningState
         )
 
         // If reasoning shows critical issues, warn but continue
@@ -160,11 +161,9 @@ export class CommandExecutor {
       }
 
       // 3. AGENTIC: Claude decides agent assignment via templates
-      let context: Record<string, unknown> = metadataContext as unknown as Record<string, unknown>
-
-      // Provide agent info to context so Claude can delegate
-      context = {
-        ...context,
+      // Build context with agent routing info for Claude delegation
+      const context: PromptContext = {
+        ...metadataContext,
         agentsPath: path.join(os.homedir(), '.prjct-cli', 'projects', metadataContext.projectId || '', 'agents'),
         agentRoutingPath: path.join(__dirname, '..', '..', 'templates', 'agentic', 'agent-routing.md'),
         agenticDelegation: true,
@@ -205,7 +204,7 @@ export class CommandExecutor {
       // Agent is null - Claude assigns via Task tool using agent-routing.md
       const prompt = promptBuilder.build(
         template,
-        context as Parameters<typeof promptBuilder.build>[1],
+        context,
         state,
         null,
         learnedPatterns,

package/core/agentic/context-builder.ts

@@ -9,6 +9,7 @@
 import fs from 'fs/promises'
 import pathManager from '../infrastructure/path-manager'
 import configManager from '../infrastructure/config-manager'
+import { isNotFoundError } from '../types/fs'
 import type { ContextPaths, ProjectContext, ContextState } from '../types'
 
 // Re-export types for convenience
@@ -113,10 +114,14 @@ class ContextBuilder {
             this._cache.delete(filePath)
             this._mtimes.delete(filePath)
           }
-        } catch {
-          // File doesn't exist - invalidate cache
-          this._cache.delete(filePath)
-          this._mtimes.delete(filePath)
+        } catch (error) {
+          // File doesn't exist or access error - invalidate cache
+          if (isNotFoundError(error)) {
+            this._cache.delete(filePath)
+            this._mtimes.delete(filePath)
+          } else {
+            throw error
+          }
         }
       }
     }
@@ -137,8 +142,11 @@ class ContextBuilder {
         try {
           const [content, stat] = await Promise.all([fs.readFile(filePath, 'utf-8'), fs.stat(filePath)])
           return { key, filePath, content, mtime: stat.mtimeMs }
-        } catch {
-          return { key, filePath, content: null, mtime: null }
+        } catch (error) {
+          if (isNotFoundError(error)) {
+            return { key, filePath, content: null, mtime: null }
+          }
+          throw error
         }
       })
 
@@ -227,8 +235,11 @@ class ContextBuilder {
         try {
           const content = await fs.readFile(filePath, 'utf-8')
           return { filePath, content }
-        } catch {
-          return { filePath, content: null }
+        } catch (error) {
+          if (isNotFoundError(error)) {
+            return { filePath, content: null }
+          }
+          throw error
         }
       })
 
@@ -264,8 +275,11 @@ class ContextBuilder {
     try {
       await fs.access(filePath)
       return true
-    } catch {
-      return false
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        return false
+      }
+      throw error
     }
   }