prjct-cli 0.11.5 → 0.12.0

package/core/domain/task-stack/task-stack.ts

@@ -0,0 +1,340 @@
+/**
+ * Task Stack Manager - Core class
+ * Handles multiple concurrent tasks with pause/resume capability
+ */
+
+import path from 'path'
+import fs from 'fs/promises'
+import { exec } from 'child_process'
+import { promisify } from 'util'
+import type { TaskEntry, MigrationResult, SwitchResult, StackSummary } from './types'
+import { parseNowFile, formatDuration } from './parser'
+import { ensureStackFile, appendToStack, readStack, writeStack, updateNowFile } from './storage'
+
+const execAsync = promisify(exec)
+
+export class TaskStack {
+  projectPath: string
+  stackPath: string
+  nowPath: string
+
+  constructor(projectPath: string) {
+    this.projectPath = projectPath
+    this.stackPath = path.join(projectPath, 'core', 'stack.jsonl')
+    this.nowPath = path.join(projectPath, 'core', 'now.md')
+  }
+
+  /**
+   * Initialize stack system - migrate from legacy now.md if needed
+   */
+  async initialize(): Promise<MigrationResult> {
+    try {
+      // Check if stack already exists
+      await fs.access(this.stackPath)
+      return { migrated: false }
+    } catch {
+      // Stack doesn't exist, check for legacy now.md
+      return await this.migrateFromLegacy()
+    }
+  }
+
+  /**
+   * Migrate from legacy now.md to stack system
+   */
+  async migrateFromLegacy(): Promise<MigrationResult> {
+    try {
+      const nowContent = await fs.readFile(this.nowPath, 'utf8')
+
+      if (!nowContent.trim() || nowContent.includes('No active task')) {
+        // Empty or no task, just create empty stack
+        await ensureStackFile(this.stackPath)
+        return { migrated: true, hadTask: false }
+      }
+
+      // Parse task from now.md
+      const task = parseNowFile(nowContent)
+
+      // Create initial stack entry
+      const entry: TaskEntry = {
+        id: `task-${Date.now()}`,
+        task: task.description || 'Migrated task',
+        agent: task.agent || 'unknown',
+        status: 'active',
+        started: task.started || new Date().toISOString(),
+        paused: null,
+        resumed: null,
+        completed: null,
+        duration: null,
+        complexity: task.complexity || 'moderate',
+        dev: task.dev || 'unknown',
+      }
+
+      // Write to stack
+      await appendToStack(this.stackPath, entry)
+
+      return { migrated: true, hadTask: true, task: entry }
+    } catch (error) {
+      // No now.md or error reading, just create empty stack
+      await ensureStackFile(this.stackPath)
+      return { migrated: true, hadTask: false, error: (error as Error).message }
+    }
+  }
+
+  // Re-expose parseNowFile for compatibility
+  parseNowFile(content: string) {
+    return parseNowFile(content)
+  }
+
+  // Re-expose formatDuration for compatibility
+  formatDuration(ms: number): string {
+    return formatDuration(ms)
+  }
+
+  /**
+   * Get active task
+   */
+  async getActiveTask(): Promise<TaskEntry | null> {
+    const stack = await readStack(this.stackPath)
+    return stack.find((task) => task.status === 'active') || null
+  }
+
+  /**
+   * Get paused tasks
+   */
+  async getPausedTasks(): Promise<TaskEntry[]> {
+    const stack = await readStack(this.stackPath)
+    return stack
+      .filter((task) => task.status === 'paused')
+      .sort((a, b) => new Date(b.paused!).getTime() - new Date(a.paused!).getTime())
+  }
+
+  /**
+   * Get all incomplete tasks
+   */
+  async getIncompleteTasks(): Promise<TaskEntry[]> {
+    const stack = await readStack(this.stackPath)
+    return stack.filter((task) => task.status !== 'completed')
+  }
+
+  /**
+   * Start a new task
+   */
+  async startTask(description: string, agent: string = 'general', complexity: string = 'moderate'): Promise<TaskEntry> {
+    // Check if there's already an active task
+    const active = await this.getActiveTask()
+    if (active) {
+      throw new Error(`Already working on: ${active.task}. Use /p:pause to pause it first.`)
+    }
+
+    const entry: TaskEntry = {
+      id: `task-${Date.now()}`,
+      task: description,
+      agent,
+      status: 'active',
+      started: new Date().toISOString(),
+      paused: null,
+      resumed: null,
+      completed: null,
+      duration: null,
+      complexity,
+      dev: await this.getCurrentDev(),
+    }
+
+    await appendToStack(this.stackPath, entry)
+    await updateNowFile(this.nowPath, entry, null, formatDuration)
+
+    return entry
+  }
+
+  /**
+   * Pause the active task
+   */
+  async pauseTask(reason: string = ''): Promise<TaskEntry> {
+    const active = await this.getActiveTask()
+    if (!active) {
+      throw new Error('No active task to pause')
+    }
+
+    // Update the task
+    active.status = 'paused'
+    active.paused = new Date().toISOString()
+    if (reason) {
+      active.pauseReason = reason
+    }
+
+    // Rewrite stack with updated task
+    await this.updateTask(active)
+
+    // Update now.md to show paused state
+    await updateNowFile(this.nowPath, null, `Paused: ${active.task}`, formatDuration)
+
+    return active
+  }
+
+  /**
+   * Resume a paused task
+   */
+  async resumeTask(taskId: string | null = null): Promise<TaskEntry> {
+    // Check if there's an active task
+    const active = await this.getActiveTask()
+    if (active) {
+      throw new Error(`Already working on: ${active.task}. Complete or pause it first.`)
+    }
+
+    const paused = await this.getPausedTasks()
+    if (paused.length === 0) {
+      throw new Error('No paused tasks to resume')
+    }
+
+    let taskToResume: TaskEntry | undefined
+    if (taskId) {
+      taskToResume = paused.find((t) => t.id === taskId)
+      if (!taskToResume) {
+        throw new Error(`Task ${taskId} not found or not paused`)
+      }
+    } else {
+      // Resume most recently paused
+      taskToResume = paused[0]
+    }
+
+    // Update the task
+    taskToResume.status = 'active'
+    taskToResume.resumed = new Date().toISOString()
+
+    // Calculate paused duration
+    if (taskToResume.paused) {
+      const pausedMs = Date.now() - new Date(taskToResume.paused).getTime()
+      taskToResume.pausedDuration = (taskToResume.pausedDuration || 0) + pausedMs
+    }
+
+    // Rewrite stack with updated task
+    await this.updateTask(taskToResume)
+
+    // Update now.md
+    await updateNowFile(this.nowPath, taskToResume, null, formatDuration)
+
+    return taskToResume
+  }
+
+  /**
+   * Complete the active task
+   */
+  async completeTask(): Promise<TaskEntry> {
+    const active = await this.getActiveTask()
+    if (!active) {
+      throw new Error('No active task to complete')
+    }
+
+    // Update the task
+    active.status = 'completed'
+    active.completed = new Date().toISOString()
+
+    // Calculate duration (excluding paused time)
+    const totalMs = Date.now() - new Date(active.started).getTime()
+    const pausedMs = active.pausedDuration || 0
+    active.duration = totalMs - pausedMs
+    active.durationFormatted = formatDuration(active.duration)
+
+    // Rewrite stack with updated task
+    await this.updateTask(active)
+
+    // Clear now.md
+    await updateNowFile(this.nowPath, null, '', formatDuration)
+
+    return active
+  }
+
+  /**
+   * Switch tasks (atomic pause + resume/start)
+   */
+  async switchTask(targetTaskOrDescription: string): Promise<SwitchResult> {
+    const active = await this.getActiveTask()
+    let pausedTask: TaskEntry | null = null
+
+    // Pause current if exists
+    if (active) {
+      pausedTask = await this.pauseTask('Switched to another task')
+    }
+
+    try {
+      // Check if target is a task ID or description
+      const paused = await this.getPausedTasks()
+      const existingTask = paused.find((t) => t.id === targetTaskOrDescription)
+
+      if (existingTask) {
+        // Resume existing task
+        return {
+          paused: pausedTask,
+          resumed: await this.resumeTask(targetTaskOrDescription),
+          type: 'resumed',
+        }
+      } else {
+        // Start new task
+        return {
+          paused: pausedTask,
+          started: await this.startTask(targetTaskOrDescription),
+          type: 'started',
+        }
+      }
+    } catch (error) {
+      // If switch fails, resume the original task
+      if (pausedTask) {
+        await this.resumeTask(pausedTask.id)
+      }
+      throw error
+    }
+  }
+
+  /**
+   * Update a task in the stack
+   */
+  async updateTask(updatedTask: TaskEntry): Promise<void> {
+    const stack = await readStack(this.stackPath)
+    const index = stack.findIndex((t) => t.id === updatedTask.id)
+
+    if (index === -1) {
+      throw new Error(`Task ${updatedTask.id} not found`)
+    }
+
+    stack[index] = updatedTask
+    await writeStack(this.stackPath, stack)
+  }
+
+  /**
+   * Update now.md to reflect current state
+   */
+  async updateNowFile(task: TaskEntry | null, customContent: string | null = null): Promise<void> {
+    await updateNowFile(this.nowPath, task, customContent, formatDuration)
+  }
+
+  /**
+   * Get current developer from git or system
+   */
+  async getCurrentDev(): Promise<string> {
+    try {
+      const { stdout } = await execAsync('git config user.name')
+      return stdout.trim()
+    } catch {
+      return 'unknown'
+    }
+  }
+
+  /**
+   * Get stack summary for display
+   */
+  async getStackSummary(): Promise<StackSummary> {
+    const active = await this.getActiveTask()
+    const paused = await this.getPausedTasks()
+    const stack = await readStack(this.stackPath)
+    const completed = stack.filter((t) => t.status === 'completed')
+
+    return {
+      active,
+      paused,
+      pausedCount: paused.length,
+      completed,
+      completedCount: completed.length,
+      totalTasks: stack.length,
+    }
+  }
+}

package/core/domain/task-stack/types.ts

@@ -0,0 +1,51 @@
+/**
+ * Task Stack Types
+ */
+
+export interface TaskEntry {
+  id: string
+  task: string
+  agent: string
+  status: 'active' | 'paused' | 'completed'
+  started: string
+  paused: string | null
+  resumed: string | null
+  completed: string | null
+  duration: number | null
+  durationFormatted?: string
+  complexity: string
+  dev: string
+  pauseReason?: string
+  pausedDuration?: number
+}
+
+export interface ParsedNowFile {
+  description: string
+  started: string | null
+  agent: string | null
+  complexity: string | null
+  dev: string | null
+}
+
+export interface MigrationResult {
+  migrated: boolean
+  hadTask?: boolean
+  task?: TaskEntry
+  error?: string
+}
+
+export interface SwitchResult {
+  paused: TaskEntry | null
+  resumed?: TaskEntry
+  started?: TaskEntry
+  type: 'resumed' | 'started'
+}
+
+export interface StackSummary {
+  active: TaskEntry | null
+  paused: TaskEntry[]
+  pausedCount: number
+  completed: TaskEntry[]
+  completedCount: number
+  totalTasks: number
+}

package/core/domain/task-stack.ts

@@ -0,0 +1,8 @@
+/**
+ * Task Stack Manager
+ * Re-exports from task-stack/index.ts for backwards compatibility.
+ */
+
+import TaskStack from './task-stack/index'
+export * from './task-stack/index'
+export default TaskStack

package/core/{index.js → index.ts}

@@ -4,17 +4,37 @@
  * This file is required by bin/prjct after setup verification
  */
 
-const { PrjctCommands } = require('./commands')
-const registry = require('./command-registry')
-const out = require('./utils/output')
+import { PrjctCommands } from './commands'
+import registry from './command-registry'
+import out from './utils/output'
+
+interface Command {
+  name: string
+  description: string
+  category: string
+  params?: string
+  implemented: boolean
+  deprecated?: boolean
+  replacedBy?: string
+}
+
+interface ParsedCommandArgs {
+  parsedArgs: string[]
+  options: Record<string, string | boolean>
+}
+
+interface CommandResult {
+  success?: boolean
+  message?: string
+}
 
-async function main() {
+async function main(): Promise<void> {
   const [commandName, ...rawArgs] = process.argv.slice(2)
 
   // === SPECIAL COMMANDS (version, help) ===
 
   if (['-v', '--version', 'version'].includes(commandName)) {
-    const packageJson = require('../package.json')
+    const packageJson = await import('../package.json')
     console.log(`prjct-cli v${packageJson.version}`)
     process.exit(0)
   }
@@ -66,7 +86,7 @@ async function main() {
     const commands = new PrjctCommands()
 
     // 6. Execute command
-    let result
+    let result: CommandResult | undefined
 
     // Commands with special option handling
     if (commandName === 'design') {
@@ -87,9 +107,32 @@ async function main() {
       const taskOrNumber = parsedArgs.join(' ')
       result = await commands.build(taskOrNumber)
     } else {
-      // Standard commands
+      // Standard commands - type-safe invocation
       const param = parsedArgs.join(' ') || null
-      result = await commands[commandName](param)
+      const standardCommands: Record<string, (p: string | null) => Promise<CommandResult>> = {
+        now: (p) => commands.now(p),
+        done: () => commands.done(),
+        next: () => commands.next(),
+        init: (p) => commands.init(p),
+        feature: (p) => commands.feature(p || ''),
+        bug: (p) => commands.bug(p || ''),
+        architect: (p) => commands.architect(p || 'execute'),
+        ship: (p) => commands.ship(p),
+        context: () => commands.context(),
+        recap: () => commands.recap(),
+        stuck: (p) => commands.stuck(p || ''),
+        roadmap: () => commands.roadmap(),
+        status: () => commands.status(),
+        sync: () => commands.sync(),
+        start: () => commands.start(),
+      }
+
+      const handler = standardCommands[commandName]
+      if (handler) {
+        result = await handler(param)
+      } else {
+        throw new Error(`Command '${commandName}' has no handler`)
+      }
     }
 
     // 7. Display result
@@ -101,9 +144,9 @@ async function main() {
     out.end()
     process.exit(result && result.success ? 0 : 1)
   } catch (error) {
-    console.error('Error:', error.message)
+    console.error('Error:', (error as Error).message)
     if (process.env.DEBUG) {
-      console.error(error.stack)
+      console.error((error as Error).stack)
     }
     // Show branding footer even on error
     out.end()
@@ -114,9 +157,9 @@ async function main() {
 /**
  * Parse command arguments dynamically
  */
-function parseCommandArgs(cmd, rawArgs) {
-  const parsedArgs = []
-  const options = {}
+function parseCommandArgs(cmd: Command, rawArgs: string[]): ParsedCommandArgs {
+  const parsedArgs: string[] = []
+  const options: Record<string, string | boolean> = {}
 
   for (let i = 0; i < rawArgs.length; i++) {
     const arg = rawArgs[i]
@@ -142,12 +185,12 @@ function parseCommandArgs(cmd, rawArgs) {
 /**
  * Display help using registry
  */
-function displayHelp() {
+function displayHelp(): void {
   const categories = registry.getCategories()
-  const categorizedCommands = {}
+  const categorizedCommands: Record<string, Command[]> = {}
 
   // Group commands by category (exclude deprecated)
-  registry.getTerminalCommands().forEach((cmd) => {
+  registry.getTerminalCommands().forEach((cmd: Command) => {
     if (cmd.deprecated) return
 
     if (!categorizedCommands[cmd.category]) {
@@ -181,9 +224,9 @@ function displayHelp() {
 
 // Run CLI
 main().catch((error) => {
-  console.error('Fatal error:', error.message)
+  console.error('Fatal error:', (error as Error).message)
   if (process.env.DEBUG) {
-    console.error(error.stack)
+    console.error((error as Error).stack)
   }
   process.exit(1)
 })

package/core/infrastructure/{agent-detector.js → agent-detector.ts}

@@ -6,23 +6,61 @@
  * @version 0.5.0
  */
 
-const fs = require('fs')
-const path = require('path')
+import fs from 'fs'
+import path from 'path'
+
+interface AgentCapabilities {
+  mcp: boolean
+  filesystem: string
+  markdown: boolean
+  emojis: boolean
+  colors: boolean
+  interactive: boolean
+  agents: boolean
+}
+
+interface AgentConfig {
+  configFile: string | null
+  commandPrefix: string
+  responseStyle: string
+  dataDir: string
+  agentsDir: string | null
+  commandsDir: string | null
+}
+
+interface AgentEnvironment {
+  hasMCP: boolean
+  sandboxed: boolean
+  persistent: boolean
+  agentSystem: boolean
+}
+
+interface AgentInfo {
+  type: string
+  name: string
+  isSupported: boolean
+  capabilities: AgentCapabilities
+  config: AgentConfig
+  environment: AgentEnvironment
+}
+
+declare const global: typeof globalThis & {
+  mcp?: {
+    filesystem?: unknown
+  }
+}
 
 /**
  * Detects the current execution environment (Claude or Terminal).
  * Provides appropriate capabilities and configuration for each environment.
  */
 class AgentDetector {
-  constructor() {
-    this.detectedAgent = null
-  }
+  private detectedAgent: AgentInfo | null = null
 
   /**
    * Main detection method - Claude or CLI fallback
-   * @returns {Object} Agent information
    */
-  async detect() {
+  async detect(): Promise<AgentInfo> {
     if (this.detectedAgent) {
       return this.detectedAgent
     }
@@ -40,9 +78,8 @@ class AgentDetector {
 
   /**
    * Check if running in Claude environment
-   * @returns {boolean} True if Claude detected
    */
-  isClaudeEnvironment() {
+  isClaudeEnvironment(): boolean {
     // Environment variables
     if (process.env.CLAUDE_AGENT || process.env.ANTHROPIC_CLAUDE) {
       return true
@@ -78,7 +115,7 @@ class AgentDetector {
    * Get Claude agent configuration
    * Works for both Claude Code and Claude Desktop
    */
-  getClaudeAgent() {
+  getClaudeAgent(): AgentInfo {
     return {
       type: 'claude',
       name: 'Claude (Code + Desktop)',
@@ -112,7 +149,7 @@ class AgentDetector {
   /**
    * Get terminal agent configuration (fallback)
    */
-  getTerminalAgent() {
+  getTerminalAgent(): AgentInfo {
     return {
       type: 'terminal',
       name: 'Terminal/CLI',
@@ -146,7 +183,7 @@ class AgentDetector {
   /**
    * Force set agent type (for testing)
    */
-  setAgent(type) {
+  setAgent(type: string): AgentInfo {
     switch (type) {
       case 'claude':
         this.detectedAgent = this.getClaudeAgent()
@@ -162,26 +199,25 @@ class AgentDetector {
   /**
    * Reset detection (clear cache)
    */
-  reset() {
+  reset(): void {
     this.detectedAgent = null
   }
 
   /**
    * Check if current environment is Claude
-   * @returns {boolean} True if Claude
    */
-  isClaude() {
+  isClaude(): boolean {
     const agent = this.detectedAgent || this.isClaudeEnvironment()
-    return agent === true || (agent && agent.type === 'claude')
+    return agent === true || (typeof agent === 'object' && agent?.type === 'claude')
   }
 
   /**
    * Check if current environment is Terminal/CLI
-   * @returns {boolean} True if terminal
    */
-  isTerminal() {
+  isTerminal(): boolean {
     return !this.isClaude()
   }
 }
 
-module.exports = new AgentDetector()
+const agentDetector = new AgentDetector()
+export default agentDetector