prjct-cli 1.22.0 → 1.23.0

package/core/workflow/state-machine.ts

@@ -1,198 +0,0 @@
-/**
- * Workflow State Machine
- * Explicit states with valid transitions for prjct workflow.
- *
- * States: idle → working → completed → shipped
- *                ↓↑          ↓↑
- *              paused ──────→ shipped (fast-track)
- *         completed ──reopen──→ working
- */
-
-// =============================================================================
-// Types
-// =============================================================================
-
-export type WorkflowState = 'idle' | 'working' | 'paused' | 'completed' | 'shipped'
-
-export type WorkflowCommand = 'task' | 'done' | 'pause' | 'resume' | 'ship' | 'next' | 'reopen'
-
-interface StateDefinition {
-  transitions: WorkflowCommand[]
-  prompt: string
-  description: string
-}
-
-interface TransitionResult {
-  valid: boolean
-  error?: string
-  suggestion?: string
-}
-
-// =============================================================================
-// State Definitions
-// =============================================================================
-
-const WORKFLOW_STATES: Record<WorkflowState, StateDefinition> = {
-  idle: {
-    transitions: ['task', 'next'],
-    prompt: 'p. task <description>  Start working',
-    description: 'No active task',
-  },
-  working: {
-    transitions: ['done', 'pause'],
-    prompt: 'p. done  Complete task  |  p. pause  Switch context',
-    description: 'Task in progress',
-  },
-  paused: {
-    transitions: ['resume', 'task', 'ship'],
-    prompt: 'p. resume  Continue  |  p. task <new>  Start different  |  p. ship  Ship directly',
-    description: 'Task paused',
-  },
-  completed: {
-    transitions: ['ship', 'task', 'next', 'pause', 'reopen'],
-    prompt: 'p. ship  Ship it  |  p. task <next>  Start next  |  p. reopen  Reopen for rework',
-    description: 'Task completed',
-  },
-  shipped: {
-    transitions: ['task', 'next'],
-    prompt: 'p. task <description>  Start new task',
-    description: 'Feature shipped',
-  },
-}
-
-// =============================================================================
-// State Machine
-// =============================================================================
-
-export class WorkflowStateMachine {
-  /**
-   * Get current state from storage state
-   */
-  getCurrentState(storageState: {
-    currentTask?: Record<string, unknown> | null
-    pausedTasks?: unknown[]
-    previousTask?: Record<string, unknown> | null
-  }): WorkflowState {
-    const task = storageState?.currentTask
-
-    if (!task) {
-      // Check if there are paused tasks (array or legacy previousTask)
-      const hasPaused =
-        (storageState?.pausedTasks?.length || 0) > 0 ||
-        storageState?.previousTask?.status === 'paused'
-      return hasPaused ? 'paused' : 'idle'
-    }
-
-    const status = (typeof task.status === 'string' ? task.status : '').toLowerCase()
-
-    switch (status) {
-      case 'in_progress':
-      case 'working':
-        return 'working'
-      case 'paused':
-        return 'paused'
-      case 'completed':
-      case 'done':
-        return 'completed'
-      case 'shipped':
-        return 'shipped'
-      default:
-        return task ? 'working' : 'idle'
-    }
-  }
-
-  /**
-   * Check if a command is valid for the current state
-   */
-  canTransition(currentState: WorkflowState, command: WorkflowCommand): TransitionResult {
-    const stateConfig = WORKFLOW_STATES[currentState]
-
-    if (stateConfig.transitions.includes(command)) {
-      return { valid: true }
-    }
-
-    // Build helpful error message
-    const validCommands = stateConfig.transitions.map((c) => `p. ${c}`).join(', ')
-
-    return {
-      valid: false,
-      error: `Cannot run 'p. ${command}' in ${currentState} state`,
-      suggestion: `Valid commands: ${validCommands}`,
-    }
-  }
-
-  /**
-   * Get the next state after a command
-   */
-  getNextState(currentState: WorkflowState, command: WorkflowCommand): WorkflowState {
-    switch (command) {
-      case 'task':
-        return 'working'
-      case 'done':
-        return 'completed'
-      case 'pause':
-        return 'paused'
-      case 'resume':
-        return 'working'
-      case 'ship':
-        return 'shipped'
-      case 'reopen':
-        return 'working'
-      case 'next':
-        return currentState // next doesn't change state
-      default:
-        return currentState
-    }
-  }
-
-  /**
-   * Get state definition
-   */
-  getStateInfo(state: WorkflowState): StateDefinition {
-    return WORKFLOW_STATES[state]
-  }
-
-  /**
-   * Get prompt for current state
-   */
-  getPrompt(state: WorkflowState): string {
-    return WORKFLOW_STATES[state].prompt
-  }
-
-  /**
-   * Get valid commands for current state
-   */
-  getValidCommands(state: WorkflowState): WorkflowCommand[] {
-    return WORKFLOW_STATES[state].transitions
-  }
-
-  /**
-   * Format next steps for display
-   */
-  formatNextSteps(state: WorkflowState): string[] {
-    const stateConfig = WORKFLOW_STATES[state]
-    return stateConfig.transitions.map((cmd) => {
-      switch (cmd) {
-        case 'task':
-          return 'p. task <desc>  Start new task'
-        case 'done':
-          return 'p. done         Complete current task'
-        case 'pause':
-          return 'p. pause        Pause and switch context'
-        case 'resume':
-          return 'p. resume       Continue paused task'
-        case 'ship':
-          return 'p. ship         Ship the feature'
-        case 'reopen':
-          return 'p. reopen       Reopen for rework'
-        case 'next':
-          return 'p. next         View task queue'
-        default:
-          return `p. ${cmd}`
-      }
-    })
-  }
-}
-
-// Singleton
-export const workflowStateMachine = new WorkflowStateMachine()

package/core/workflow/workflow-preferences.ts

@@ -1,294 +0,0 @@
-/**
- * Workflow Preferences - Natural Language Driven Hooks
- *
- * Users configure workflow hooks via natural language.
- * The LLM interprets preferences and stores them in memory.
- *
- * Scopes:
- * - permanent: persisted via memorySystem.recordDecision()
- * - session: in-memory Map, cleared on process exit
- * - once: consumed after first use
- *
- * @see PRJ-137
- * @module workflow/workflow-preferences
- */
-
-import { exec } from 'node:child_process'
-import { promisify } from 'node:util'
-import chalk from 'chalk'
-import memorySystem from '../agentic/memory-system'
-import { WORKFLOW_HELP } from '../constants'
-import type {
-  HookCommand,
-  HookPhase,
-  HookResult,
-  PreferenceScope,
-  WorkflowPreference,
-} from '../types'
-import { getErrorMessage } from '../types/fs'
-
-const execAsync = promisify(exec)
-
-export type {
-  HookCommand,
-  HookPhase,
-  HookResult,
-  PreferenceScope,
-  WorkflowPreference,
-} from '../types'
-
-// Session and once preferences (in-memory)
-const sessionPreferences: Map<string, WorkflowPreference> = new Map()
-const oncePreferences: Map<string, WorkflowPreference> = new Map()
-
-/**
- * Generate a key for a preference
- */
-function prefKey(hook: HookPhase, command: HookCommand): string {
-  return `workflow:${hook}_${command}`
-}
-
-/**
- * Set a workflow preference
- */
-export async function setWorkflowPreference(
-  projectId: string,
-  pref: WorkflowPreference
-): Promise<void> {
-  const key = prefKey(pref.hook, pref.command)
-
-  switch (pref.scope) {
-    case 'permanent':
-      // Use memory system for persistent storage
-      await memorySystem.recordDecision(projectId, key, pref.action, 'workflow')
-      break
-    case 'session':
-      sessionPreferences.set(key, pref)
-      break
-    case 'once':
-      oncePreferences.set(key, pref)
-      break
-  }
-}
-
-/**
- * Get workflow preferences for a command
- * Combines permanent + session + once preferences
- */
-export async function getWorkflowPreferences(
-  projectId: string,
-  command: HookCommand
-): Promise<{
-  before?: string
-  after?: string
-  skip?: boolean
-}> {
-  const result: {
-    before?: string
-    after?: string
-    skip?: boolean
-  } = {}
-
-  // Check each phase
-  for (const phase of ['before', 'after', 'skip'] as const) {
-    const key = prefKey(phase, command)
-
-    // Check once first (highest priority)
-    const once = oncePreferences.get(key)
-    if (once) {
-      if (phase === 'skip') {
-        result.skip = once.action === 'true'
-      } else {
-        result[phase] = once.action
-      }
-      continue
-    }
-
-    // Check session
-    const session = sessionPreferences.get(key)
-    if (session) {
-      if (phase === 'skip') {
-        result.skip = session.action === 'true'
-      } else {
-        result[phase] = session.action
-      }
-      continue
-    }
-
-    // Check permanent (via memory system)
-    const permanent = await memorySystem.getSmartDecision(projectId, key)
-    if (permanent) {
-      if (phase === 'skip') {
-        result.skip = permanent === 'true'
-      } else {
-        result[phase] = permanent
-      }
-    }
-  }
-
-  return result
-}
-
-/**
- * Run workflow hooks for a command
- * Consumes 'once' preferences after use
- */
-export async function runWorkflowHooks(
-  projectId: string,
-  phase: 'before' | 'after',
-  command: HookCommand,
-  options: { projectPath?: string; skipHooks?: boolean } = {}
-): Promise<HookResult> {
-  if (options.skipHooks) {
-    return { success: true }
-  }
-
-  const prefs = await getWorkflowPreferences(projectId, command)
-
-  // Check if this step should be skipped
-  if (prefs.skip) {
-    return { success: true, skipped: [command] }
-  }
-
-  const action = prefs[phase]
-  if (!action) {
-    return { success: true }
-  }
-
-  // Consume 'once' preference if it exists
-  const key = prefKey(phase, command)
-  if (oncePreferences.has(key)) {
-    oncePreferences.delete(key)
-  }
-
-  console.log(`\n${chalk.dim(`Running ${phase}-${command}: ${action}`)}`)
-
-  try {
-    const startTime = Date.now()
-    await execAsync(action, {
-      timeout: 60000,
-      cwd: options.projectPath || process.cwd(),
-      env: { ...process.env },
-    })
-    const elapsed = Date.now() - startTime
-    const timeStr = elapsed > 1000 ? `${(elapsed / 1000).toFixed(1)}s` : `${elapsed}ms`
-    console.log(`${chalk.green('✓')} ${chalk.dim(`(${timeStr})`)}`)
-    return { success: true }
-  } catch (error) {
-    console.log(chalk.red('✗ failed'))
-    const errorMessage = getErrorMessage(error) || 'Unknown error'
-    console.log(chalk.dim(errorMessage.split('\n')[0]))
-    return { success: false, failed: action, output: errorMessage }
-  }
-}
-
-/**
- * List all workflow preferences for a project
- */
-export async function listWorkflowPreferences(projectId: string): Promise<
-  Array<{
-    key: string
-    action: string
-    scope: PreferenceScope
-  }>
-> {
-  const results: Array<{
-    key: string
-    action: string
-    scope: PreferenceScope
-  }> = []
-
-  const commands: HookCommand[] = ['task', 'done', 'ship', 'sync']
-  const phases: HookPhase[] = ['before', 'after', 'skip']
-
-  for (const command of commands) {
-    for (const phase of phases) {
-      const key = prefKey(phase, command)
-
-      // Check once
-      const once = oncePreferences.get(key)
-      if (once) {
-        results.push({ key: `${phase} ${command}`, action: once.action, scope: 'once' })
-        continue
-      }
-
-      // Check session
-      const session = sessionPreferences.get(key)
-      if (session) {
-        results.push({ key: `${phase} ${command}`, action: session.action, scope: 'session' })
-        continue
-      }
-
-      // Check permanent
-      const permanent = await memorySystem.getSmartDecision(projectId, key)
-      if (permanent) {
-        results.push({ key: `${phase} ${command}`, action: permanent, scope: 'permanent' })
-      }
-    }
-  }
-
-  return results
-}
-
-/**
- * Remove a workflow preference
- */
-export async function removeWorkflowPreference(
-  projectId: string,
-  hook: HookPhase,
-  command: HookCommand
-): Promise<boolean> {
-  const key = prefKey(hook, command)
-
-  // Remove from all scopes
-  oncePreferences.delete(key)
-  sessionPreferences.delete(key)
-
-  // For permanent, we record an empty value
-  // (the memory system will treat low-confidence empty values as non-existent)
-  await memorySystem.recordDecision(projectId, key, '', 'workflow:remove')
-
-  return true
-}
-
-/**
- * Format workflow preferences for display
- */
-export function formatWorkflowPreferences(
-  preferences: Array<{
-    key: string
-    action: string
-    scope: PreferenceScope
-  }>
-): string {
-  if (preferences.length === 0) {
-    return `${chalk.dim(WORKFLOW_HELP.NO_PREFERENCES)}\n\nSet one: "${WORKFLOW_HELP.SET_EXAMPLE}"`
-  }
-
-  const lines: string[] = ['', 'WORKFLOW PREFERENCES', '────────────────────────────']
-
-  for (const pref of preferences) {
-    const scopeBadge =
-      pref.scope === 'permanent'
-        ? chalk.green('permanent')
-        : pref.scope === 'session'
-          ? chalk.yellow('session')
-          : chalk.dim('once')
-
-    lines.push(`  [${scopeBadge}] ${pref.key.padEnd(15)} → ${pref.action}`)
-  }
-
-  lines.push('')
-  lines.push(chalk.dim(`Modify: "${WORKFLOW_HELP.MODIFY_EXAMPLE}"`))
-  lines.push(chalk.dim(`Remove: "${WORKFLOW_HELP.REMOVE_EXAMPLE}"`))
-
-  return lines.join('\n')
-}
-
-/**
- * Clear all session preferences (for testing)
- */
-export function clearSessionPreferences(): void {
-  sessionPreferences.clear()
-  oncePreferences.clear()
-}