prjct-cli 0.44.1 → 0.45.3

package/core/agentic/memory-system.ts

@@ -11,43 +11,42 @@
  * @version 3.3
  */
 
-import fs from 'fs/promises'
-import path from 'path'
+import fs from 'node:fs/promises'
+import path from 'node:path'
 import pathManager from '../infrastructure/path-manager'
-import { isNotFoundError } from '../types/fs'
 import { generateUUID } from '../schemas'
+import { isNotFoundError } from '../types/fs'
 import { getTimestamp, getTodayKey } from '../utils/date-helper'
-import { appendJsonLine, getLastJsonLines } from '../utils/jsonl-helper'
 import { ensureDir } from '../utils/file-helper'
+import { appendJsonLine, getLastJsonLines } from '../utils/jsonl-helper'
 
 // Re-export types from canonical location
 export type {
-  Memory,
-  MemoryTag,
-  MemoryDatabase,
+  Decision,
   HistoryEntry,
   HistoryEventType,
-  Decision,
-  Workflow,
-  Preference,
-  Patterns,
+  Memory,
   MemoryContext,
   MemoryContextParams,
+  MemoryDatabase,
+  MemoryTag,
+  Patterns,
+  Preference,
+  Workflow,
 } from '../types/memory'
 
 export { MEMORY_TAGS } from '../types/memory'
 
 import type {
-  Memory,
-  MemoryTag,
-  MemoryDatabase,
   HistoryEntry,
   HistoryEventType,
-  Decision,
-  Workflow,
-  Preference,
-  Patterns,
+  Memory,
   MemoryContext,
+  MemoryDatabase,
+  MemoryTag,
+  Patterns,
+  Preference,
+  Workflow,
 } from '../types/memory'
 
 import { MEMORY_TAGS } from '../types/memory'
@@ -240,10 +239,19 @@ export class HistoryStore {
     const yearMonth = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}`
     const day = getTodayKey()
 
-    return path.join(pathManager.getGlobalProjectPath(projectId), 'memory', 'sessions', yearMonth, `${day}.jsonl`)
+    return path.join(
+      pathManager.getGlobalProjectPath(projectId),
+      'memory',
+      'sessions',
+      yearMonth,
+      `${day}.jsonl`
+    )
   }
 
-  async appendHistory(projectId: string, entry: Record<string, unknown> & { type: HistoryEventType }): Promise<void> {
+  async appendHistory(
+    projectId: string,
+    entry: Record<string, unknown> & { type: HistoryEventType }
+  ): Promise<void> {
     const sessionPath = this._getSessionPath(projectId)
     await ensureDir(path.dirname(sessionPath))
 
@@ -294,7 +302,12 @@ export class PatternStore extends CachedStore<Patterns> {
     return this.save(projectId)
   }
 
-  async recordDecision(projectId: string, key: string, value: string, context: string = ''): Promise<void> {
+  async recordDecision(
+    projectId: string,
+    key: string,
+    value: string,
+    context: string = ''
+  ): Promise<void> {
     const patterns = await this.load(projectId)
     const now = getTimestamp()
 
@@ -333,7 +346,10 @@ export class PatternStore extends CachedStore<Patterns> {
     await this.save(projectId)
   }
 
-  async getDecision(projectId: string, key: string): Promise<{ value: string; confidence: string } | null> {
+  async getDecision(
+    projectId: string,
+    key: string
+  ): Promise<{ value: string; confidence: string } | null> {
     const patterns = await this.load(projectId)
     const decision = patterns.decisions[key]
 
@@ -348,7 +364,11 @@ export class PatternStore extends CachedStore<Patterns> {
     return decision !== null
   }
 
-  async recordWorkflow(projectId: string, workflowName: string, pattern: Record<string, unknown>): Promise<void> {
+  async recordWorkflow(
+    projectId: string,
+    workflowName: string,
+    pattern: Record<string, unknown>
+  ): Promise<void> {
     const patterns = await this.load(projectId)
     const now = getTimestamp()
 
@@ -381,7 +401,11 @@ export class PatternStore extends CachedStore<Patterns> {
     await this.save(projectId)
   }
 
-  async getPreference(projectId: string, key: string, defaultValue: unknown = null): Promise<unknown> {
+  async getPreference(
+    projectId: string,
+    key: string,
+    defaultValue: unknown = null
+  ): Promise<unknown> {
     const patterns = await this.load(projectId)
     return patterns.preferences[key]?.value ?? defaultValue
   }
@@ -391,7 +415,8 @@ export class PatternStore extends CachedStore<Patterns> {
 
     return {
       decisions: Object.keys(patterns.decisions).length,
-      learnedDecisions: Object.values(patterns.decisions).filter((d) => d.confidence !== 'low').length,
+      learnedDecisions: Object.values(patterns.decisions).filter((d) => d.confidence !== 'low')
+        .length,
       workflows: Object.keys(patterns.workflows).length,
       preferences: Object.keys(patterns.preferences).length,
     }
@@ -535,7 +560,11 @@ export class SemanticMemories extends CachedStore<MemoryDatabase> {
     return true
   }
 
-  async findByTags(projectId: string, tags: string[], matchAll: boolean = false): Promise<Memory[]> {
+  async findByTags(
+    projectId: string,
+    tags: string[],
+    matchAll: boolean = false
+  ): Promise<Memory[]> {
     const db = await this.load(projectId)
     const parsedTags = this._coerceTags(tags)
 
@@ -556,11 +585,16 @@ export class SemanticMemories extends CachedStore<MemoryDatabase> {
     const queryLower = query.toLowerCase()
 
     return db.memories.filter(
-      (m) => m.title.toLowerCase().includes(queryLower) || m.content.toLowerCase().includes(queryLower)
+      (m) =>
+        m.title.toLowerCase().includes(queryLower) || m.content.toLowerCase().includes(queryLower)
     )
   }
 
-  async getRelevantMemories(projectId: string, context: MemoryContext, limit: number = 5): Promise<Memory[]> {
+  async getRelevantMemories(
+    projectId: string,
+    context: MemoryContext,
+    limit: number = 5
+  ): Promise<Memory[]> {
     const db = await this.load(projectId)
 
     const scored = db.memories.map((memory) => {
@@ -625,7 +659,12 @@ export class SemanticMemories extends CachedStore<MemoryDatabase> {
     return keywords.filter((k) => k.length > 2 && !stopWords.includes(k))
   }
 
-  async autoRemember(projectId: string, decisionType: string, value: string, context: string = ''): Promise<void> {
+  async autoRemember(
+    projectId: string,
+    decisionType: string,
+    value: string,
+    context: string = ''
+  ): Promise<void> {
     const tagMap: Record<string, string[]> = {
       commit_footer: [MEMORY_TAGS.COMMIT_STYLE],
       branch_naming: [MEMORY_TAGS.BRANCH_NAMING],
@@ -736,11 +775,20 @@ export class MemorySystem {
     return this._semanticMemories.searchMemories(projectId, query)
   }
 
-  getRelevantMemories(projectId: string, context: MemoryContext, limit?: number): Promise<Memory[]> {
+  getRelevantMemories(
+    projectId: string,
+    context: MemoryContext,
+    limit?: number
+  ): Promise<Memory[]> {
     return this._semanticMemories.getRelevantMemories(projectId, context, limit)
   }
 
-  autoRemember(projectId: string, decisionType: string, value: string, context?: string): Promise<void> {
+  autoRemember(
+    projectId: string,
+    decisionType: string,
+    value: string,
+    context?: string
+  ): Promise<void> {
     return this._semanticMemories.autoRemember(projectId, decisionType, value, context)
   }
 
@@ -784,7 +832,10 @@ export class MemorySystem {
     return this._patternStore.recordDecision(projectId, key, value, context)
   }
 
-  getDecision(projectId: string, key: string): Promise<{ value: string; confidence: string } | null> {
+  getDecision(
+    projectId: string,
+    key: string
+  ): Promise<{ value: string; confidence: string } | null> {
     return this._patternStore.getDecision(projectId, key)
   }
 
@@ -792,7 +843,11 @@ export class MemorySystem {
     return this._patternStore.hasPattern(projectId, key)
   }
 
-  recordWorkflow(projectId: string, workflowName: string, pattern: Record<string, unknown>): Promise<void> {
+  recordWorkflow(
+    projectId: string,
+    workflowName: string,
+    pattern: Record<string, unknown>
+  ): Promise<void> {
     return this._patternStore.recordWorkflow(projectId, workflowName, pattern)
   }
 
@@ -816,7 +871,10 @@ export class MemorySystem {
   // TIER 3: History
   // ===========================================================================
 
-  appendHistory(projectId: string, entry: Record<string, unknown> & { type: HistoryEventType }): Promise<void> {
+  appendHistory(
+    projectId: string,
+    entry: Record<string, unknown> & { type: HistoryEventType }
+  ): Promise<void> {
     return this._historyStore.appendHistory(projectId, entry)
   }
 
@@ -838,7 +896,12 @@ export class MemorySystem {
     return null
   }
 
-  async learnDecision(projectId: string, key: string, value: string, context: string = ''): Promise<void> {
+  async learnDecision(
+    projectId: string,
+    key: string,
+    value: string,
+    context: string = ''
+  ): Promise<void> {
     this.setSession(`decision:${key}`, value)
     await this.recordDecision(projectId, key, value, context)
     await this.appendHistory(projectId, { type: 'decision', key, value, context })

package/core/agentic/orchestrator-executor.ts

@@ -13,20 +13,15 @@
  * @version 1.0.0
  */
 
-import fs from 'fs/promises'
-import path from 'path'
-import os from 'os'
-import pathManager from '../infrastructure/path-manager'
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
 import configManager from '../infrastructure/config-manager'
+import pathManager from '../infrastructure/path-manager'
 import { stateStorage } from '../storage'
+import type { LoadedAgent, LoadedSkill, OrchestratorContext, OrchestratorSubtask } from '../types'
 import { isNotFoundError } from '../types/fs'
 import { parseFrontmatter } from './template-loader'
-import type {
-  OrchestratorContext,
-  LoadedAgent,
-  LoadedSkill,
-  OrchestratorSubtask,
-} from '../types'
 
 // =============================================================================
 // Domain Detection Keywords
@@ -38,49 +33,139 @@ import type {
  */
 const DOMAIN_KEYWORDS: Record<string, string[]> = {
   database: [
-    'database', 'db', 'sql', 'query', 'table', 'schema', 'migration',
-    'postgres', 'mysql', 'sqlite', 'mongo', 'redis', 'prisma', 'drizzle',
-    'orm', 'model', 'entity', 'repository', 'data layer', 'persist',
+    'database',
+    'db',
+    'sql',
+    'query',
+    'table',
+    'schema',
+    'migration',
+    'postgres',
+    'mysql',
+    'sqlite',
+    'mongo',
+    'redis',
+    'prisma',
+    'drizzle',
+    'orm',
+    'model',
+    'entity',
+    'repository',
+    'data layer',
+    'persist',
   ],
   backend: [
-    'api', 'endpoint', 'route', 'server', 'controller', 'service',
-    'middleware', 'auth', 'authentication', 'authorization', 'jwt', 'oauth',
-    'rest', 'graphql', 'trpc', 'express', 'fastify', 'hono', 'nest',
-    'validation', 'business logic',
+    'api',
+    'endpoint',
+    'route',
+    'server',
+    'controller',
+    'service',
+    'middleware',
+    'auth',
+    'authentication',
+    'authorization',
+    'jwt',
+    'oauth',
+    'rest',
+    'graphql',
+    'trpc',
+    'express',
+    'fastify',
+    'hono',
+    'nest',
+    'validation',
+    'business logic',
   ],
   frontend: [
-    'ui', 'component', 'page', 'form', 'button', 'input', 'modal', 'dialog',
-    'react', 'vue', 'svelte', 'angular', 'next', 'nuxt', 'solid',
-    'css', 'style', 'tailwind', 'layout', 'responsive', 'animation',
-    'hook', 'state', 'context', 'redux', 'zustand', 'jotai',
+    'ui',
+    'component',
+    'page',
+    'form',
+    'button',
+    'input',
+    'modal',
+    'dialog',
+    'react',
+    'vue',
+    'svelte',
+    'angular',
+    'next',
+    'nuxt',
+    'solid',
+    'css',
+    'style',
+    'tailwind',
+    'layout',
+    'responsive',
+    'animation',
+    'hook',
+    'state',
+    'context',
+    'redux',
+    'zustand',
+    'jotai',
   ],
   testing: [
-    'test', 'spec', 'unit', 'integration', 'e2e', 'jest', 'vitest',
-    'playwright', 'cypress', 'mocha', 'chai', 'mock', 'stub', 'fixture',
-    'coverage', 'assertion',
+    'test',
+    'spec',
+    'unit',
+    'integration',
+    'e2e',
+    'jest',
+    'vitest',
+    'playwright',
+    'cypress',
+    'mocha',
+    'chai',
+    'mock',
+    'stub',
+    'fixture',
+    'coverage',
+    'assertion',
   ],
   devops: [
-    'docker', 'kubernetes', 'k8s', 'ci', 'cd', 'pipeline', 'deploy',
-    'github actions', 'vercel', 'aws', 'gcp', 'azure', 'terraform',
-    'nginx', 'caddy', 'env', 'environment', 'config', 'secret',
+    'docker',
+    'kubernetes',
+    'k8s',
+    'ci',
+    'cd',
+    'pipeline',
+    'deploy',
+    'github actions',
+    'vercel',
+    'aws',
+    'gcp',
+    'azure',
+    'terraform',
+    'nginx',
+    'caddy',
+    'env',
+    'environment',
+    'config',
+    'secret',
   ],
   uxui: [
-    'design', 'ux', 'user experience', 'accessibility', 'a11y',
-    'color', 'typography', 'spacing', 'prototype', 'wireframe',
-    'figma', 'user flow', 'interaction',
+    'design',
+    'ux',
+    'user experience',
+    'accessibility',
+    'a11y',
+    'color',
+    'typography',
+    'spacing',
+    'prototype',
+    'wireframe',
+    'figma',
+    'user flow',
+    'interaction',
   ],
 }
 
 /**
  * Domain dependency order - earlier domains should complete first
  */
-const DOMAIN_DEPENDENCY_ORDER = [
-  'database',
-  'backend',
-  'frontend',
-  'testing',
-  'devops',
-]
+const DOMAIN_DEPENDENCY_ORDER = ['database', 'backend', 'frontend', 'testing', 'devops']
 
 // =============================================================================
 // Orchestrator Executor Class
@@ -108,11 +193,7 @@ export class OrchestratorExecutor {
     const repoAnalysis = await this.loadRepoAnalysis(globalPath)
 
     // Step 3: Detect domains from task + project context
-    const { domains, primary } = await this.detectDomains(
-      taskDescription,
-      projectId,
-      repoAnalysis
-    )
+    const { domains, primary } = await this.detectDomains(taskDescription, projectId, repoAnalysis)
 
     // Step 4: Load agents for detected domains
     const agents = await this.loadAgents(domains, projectId)
@@ -126,12 +207,7 @@ export class OrchestratorExecutor {
     // Step 7: Create subtasks if fragmentation is required
     let subtasks: OrchestratorSubtask[] | null = null
     if (requiresFragmentation && command === 'task') {
-      subtasks = await this.createSubtasks(
-        taskDescription,
-        domains,
-        agents,
-        projectId
-      )
+      subtasks = await this.createSubtasks(taskDescription, domains, agents, projectId)
     }
 
     return {
@@ -229,10 +305,8 @@ export class OrchestratorExecutor {
       .filter(([domain]) => {
         // Check if agent exists for this domain
         return availableAgents.some(
-          agent =>
-            agent === domain ||
-            agent.includes(domain) ||
-            domain.includes(agent.replace('.md', ''))
+          (agent) =>
+            agent === domain || agent.includes(domain) || domain.includes(agent.replace('.md', ''))
         )
       })
       .sort((a, b) => b[1] - a[1]) // Sort by score descending
@@ -256,7 +330,7 @@ export class OrchestratorExecutor {
     try {
       const agentsDir = path.join(globalPath, 'agents')
       const files = await fs.readdir(agentsDir)
-      return files.filter(f => f.endsWith('.md')).map(f => f.replace('.md', ''))
+      return files.filter((f) => f.endsWith('.md')).map((f) => f.replace('.md', ''))
     } catch {
       return []
     }
@@ -275,11 +349,7 @@ export class OrchestratorExecutor {
 
     for (const domain of domains) {
       // Try exact match first, then variations
-      const possibleNames = [
-        `${domain}.md`,
-        `${domain}-agent.md`,
-        `prjct-${domain}.md`,
-      ]
+      const possibleNames = [`${domain}.md`, `${domain}-agent.md`, `prjct-${domain}.md`]
 
       for (const fileName of possibleNames) {
         const filePath = path.join(agentsDir, fileName)
@@ -297,10 +367,7 @@ export class OrchestratorExecutor {
 
           // Found one, no need to try other variations
           break
-        } catch {
-          // Try next variation
-          continue
-        }
+        } catch {}
       }
     }
 
@@ -320,12 +387,12 @@ export class OrchestratorExecutor {
     const frontmatter = { ...parsed.frontmatter }
     if (typeof frontmatter.skills === 'string') {
       // Handle comma-separated string
-      frontmatter.skills = (frontmatter.skills as string).split(',').map(s => s.trim())
+      frontmatter.skills = (frontmatter.skills as string).split(',').map((s) => s.trim())
     }
 
     return {
       frontmatter: frontmatter as { skills?: string[]; [key: string]: unknown },
-      body: parsed.content
+      body: parsed.content,
     }
   }
 
@@ -438,11 +505,11 @@ export class OrchestratorExecutor {
     // Create subtask for each domain
     const subtasks: OrchestratorSubtask[] = sortedDomains.map((domain, index) => {
       // Find the agent for this domain
-      const agent = agents.find(a => a.domain === domain)
+      const agent = agents.find((a) => a.domain === domain)
       const agentFile = agent ? `${agent.name}.md` : `${domain}.md`
 
       // Determine dependencies - each subtask depends on previous ones
-      const dependsOn = sortedDomains.slice(0, index).map((d, i) => `subtask-${i + 1}`)
+      const dependsOn = sortedDomains.slice(0, index).map((_d, i) => `subtask-${i + 1}`)
 
       return {
         id: `subtask-${index + 1}`,
@@ -458,7 +525,7 @@ export class OrchestratorExecutor {
     // Store subtasks in state.json via state storage
     await stateStorage.createSubtasks(
       projectId,
-      subtasks.map(st => ({
+      subtasks.map((st) => ({
         id: st.id,
         description: st.description,
         domain: st.domain,
@@ -473,10 +540,7 @@ export class OrchestratorExecutor {
   /**
    * Generate a domain-specific subtask description
    */
-  private generateSubtaskDescription(
-    fullTask: string,
-    domain: string
-  ): string {
+  private generateSubtaskDescription(fullTask: string, domain: string): string {
     const domainDescriptions: Record<string, string> = {
       database: 'Set up data layer: schema, models, migrations',
       backend: 'Implement API: routes, controllers, services, validation',

package/core/agentic/plan-mode.ts

@@ -8,22 +8,34 @@
  * Pattern from: Devin AI, Windsurf, Kiro
  */
 
+import { generateUUID } from '../schemas'
 import type {
-  PlanParams,
+  ApprovalContext,
+  ApprovalPrompt,
   GatheredInfo,
-  ProposedPlan,
-  PlanStep,
-  PlanStepResult,
-  PlanStatus,
   Plan,
   PlanAnalysis,
-  ApprovalPrompt,
-  ApprovalContext,
+  PlanParams,
+  PlanStatus,
+  PlanStep,
+  PlanStepResult,
+  ProposedPlan,
 } from '../types'
-import { generateUUID } from '../schemas'
 import { getTimestamp } from '../utils/date-helper'
-export { PLAN_STATUS, PLAN_REQUIRED_COMMANDS, DESTRUCTIVE_COMMANDS, PLANNING_TOOLS } from '../constants'
-import { PLAN_STATUS, PLAN_REQUIRED_COMMANDS, DESTRUCTIVE_COMMANDS, PLANNING_TOOLS } from '../constants'
+
+export {
+  DESTRUCTIVE_COMMANDS,
+  PLAN_REQUIRED_COMMANDS,
+  PLAN_STATUS,
+  PLANNING_TOOLS,
+} from '../constants'
+
+import {
+  DESTRUCTIVE_COMMANDS,
+  PLAN_REQUIRED_COMMANDS,
+  PLAN_STATUS,
+  PLANNING_TOOLS,
+} from '../constants'
 
 // =============================================================================
 // Approval
@@ -32,7 +44,10 @@ import { PLAN_STATUS, PLAN_REQUIRED_COMMANDS, DESTRUCTIVE_COMMANDS, PLANNING_TOO
 /**
  * Generate approval prompt for destructive commands
  */
-export function generateApprovalPrompt(commandName: string, context: ApprovalContext): ApprovalPrompt {
+export function generateApprovalPrompt(
+  commandName: string,
+  context: ApprovalContext
+): ApprovalPrompt {
   const prompts: Record<string, ApprovalPrompt> = {
     ship: {
       title: 'Ship Confirmation',
@@ -51,7 +66,10 @@ export function generateApprovalPrompt(commandName: string, context: ApprovalCon
     cleanup: {
       title: 'Cleanup Confirmation',
       message: 'This will delete files/code. Continue?',
-      details: [`Files to delete: ${context.filesToDelete?.length || 0}`, `Code to remove: ${context.linesOfCode || 0} lines`],
+      details: [
+        `Files to delete: ${context.filesToDelete?.length || 0}`,
+        `Code to remove: ${context.linesOfCode || 0} lines`,
+      ],
       options: [
         { key: 'y', label: 'Yes, cleanup', action: 'approve' },
         { key: 'n', label: 'No, cancel', action: 'reject' },
@@ -218,7 +236,10 @@ export class PlanMode {
   /**
    * Propose a plan for user approval
    */
-  proposePlan(projectId: string, proposedPlan: ProposedPlan): ReturnType<typeof this.formatPlanForApproval> | null {
+  proposePlan(
+    projectId: string,
+    proposedPlan: ProposedPlan
+  ): ReturnType<typeof this.formatPlanForApproval> | null {
     const plan = this.getActivePlan(projectId)
     if (!plan) return null
 
@@ -350,7 +371,10 @@ export class PlanMode {
   /**
    * Mark current step as complete
    */
-  completeStep(projectId: string, result: PlanStepResult = { success: true }): ReturnType<typeof this.getNextStep> {
+  completeStep(
+    projectId: string,
+    result: PlanStepResult = { success: true }
+  ): ReturnType<typeof this.getNextStep> {
     const plan = this.getActivePlan(projectId)
     if (!plan || plan.status !== PLAN_STATUS.EXECUTING) {
       return null
@@ -370,7 +394,10 @@ export class PlanMode {
   /**
    * Mark step as failed
    */
-  failStep(projectId: string, error: string): { failed: boolean; step: number; error: string; options: string[] } | null {
+  failStep(
+    projectId: string,
+    error: string
+  ): { failed: boolean; step: number; error: string; options: string[] } | null {
     const plan = this.getActivePlan(projectId)
     if (!plan) return null
 
@@ -461,7 +488,10 @@ export class PlanMode {
       [PLAN_STATUS.ABORTED]: '🛑',
     }
 
-    const lines = [`${statusEmoji[plan.status] || '📋'} Plan: ${plan.command}`, `Status: ${plan.status}`]
+    const lines = [
+      `${statusEmoji[plan.status] || '📋'} Plan: ${plan.command}`,
+      `Status: ${plan.status}`,
+    ]
 
     if (plan.status === PLAN_STATUS.EXECUTING) {
       const progress = Math.round((plan.currentStep / plan.steps.length) * 100)