prjct-cli 0.11.5 → 0.12.1

package/core/domain/{task-analyzer.js → task-analyzer.ts}

@@ -1,29 +1,73 @@
 /**
  * TaskAnalyzer - Deep Semantic Task Analysis
- * 
+ *
  * Analyzes tasks semantically, not just keywords
  * Considers project context, history, and relationships
- * 
+ *
  * @version 1.0.0
  */
 
-const fs = require('fs').promises
-const path = require('path')
-const analyzer = require('./analyzer')
-const configManager = require('../infrastructure/config-manager')
-const pathManager = require('../infrastructure/path-manager')
+import fs from 'fs/promises'
+import path from 'path'
+import analyzer from './analyzer'
+import configManager from '../infrastructure/config-manager'
+import pathManager from '../infrastructure/path-manager'
+
+interface Task {
+  description?: string
+  type?: string
+}
+
+interface HistoryEntry {
+  type: string
+  domain?: string
+  description?: string
+}
+
+interface SemanticAnalysis {
+  intent: string | null
+  requiresMultipleAgents: boolean
+  text: string
+}
+
+interface HistoricalAnalysis {
+  confidence: number
+  patterns: Array<{ domain: string; description: string }>
+  suggestedDomain?: string | null
+}
+
+interface ProjectData {
+  packageJson: unknown
+  extensions: Record<string, number>
+  directories: string[]
+  configFiles: string[]
+}
+
+interface TaskAnalysisResult {
+  primaryDomain: string
+  confidence: number
+  semantic: SemanticAnalysis
+  historical: HistoricalAnalysis
+  complexity: string
+  projectData: ProjectData
+  matchedKeywords: string[]
+  reason: string
+  alternatives: string[]
+}
 
 class TaskAnalyzer {
-  constructor(projectPath) {
+  projectPath: string
+  projectId: string | null = null
+  taskHistory: HistoryEntry[] | null = null
+
+  constructor(projectPath: string) {
     this.projectPath = projectPath
-    this.projectId = null
-    this.taskHistory = null
   }
 
   /**
    * Initialize analyzer with project context
    */
-  async initialize() {
+  async initialize(): Promise<void> {
     this.projectId = await configManager.getProjectId(this.projectPath)
     analyzer.init(this.projectPath)
     await this.loadTaskHistory()
@@ -34,11 +78,8 @@ class TaskAnalyzer {
    *
    * 100% AGENTIC: No hardcoded patterns. Uses task description
    * and historical patterns only. Claude decides domain relevance.
-   *
-   * @param {Object} task - Task object {description, type}
-   * @returns {Promise<Object>} Analysis result
    */
-  async analyzeTask(task) {
+  async analyzeTask(task: Task): Promise<TaskAnalysisResult> {
     if (!this.projectId) {
       await this.initialize()
     }
@@ -48,11 +89,11 @@ class TaskAnalyzer {
     const fullText = `${description} ${type}`.trim()
 
     // Get raw project data (no categorization)
-    const projectData = {
+    const projectData: ProjectData = {
       packageJson: await analyzer.readPackageJson(),
       extensions: await analyzer.getFileExtensions(),
       directories: await analyzer.listDirectories(),
-      configFiles: await analyzer.listConfigFiles()
+      configFiles: await analyzer.listConfigFiles(),
     }
 
     // Semantic understanding (intent-based, not keyword-based)
@@ -77,7 +118,7 @@ class TaskAnalyzer {
       projectData, // Raw data for Claude to analyze
       matchedKeywords: [], // No keyword matching - Claude decides
       reason: this.buildReason(primaryDomain, semantic, historical),
-      alternatives: ['full-stack', 'generalist']
+      alternatives: ['full-stack', 'generalist'],
     }
   }
 
@@ -91,7 +132,7 @@ class TaskAnalyzer {
    * This method is kept for backward compatibility but returns empty.
    * Use analyzeTask() which provides raw data for Claude.
    */
-  detectDomains(text) {
+  detectDomains(text: string): Record<string, unknown> {
     // No hardcoded patterns - Claude decides domain
     return {}
   }
@@ -101,7 +142,7 @@ class TaskAnalyzer {
    * AGENTIC: Claude uses templates/analysis/intent.md for detailed analysis
    * This returns minimal structure - Claude determines actual intent
    */
-  analyzeSemantics(text) {
+  analyzeSemantics(text: string): SemanticAnalysis {
     // AGENTIC: Return structure only, Claude analyzes via template
     return {
       intent: null, // Claude determines via templates/analysis/intent.md
@@ -113,14 +154,14 @@ class TaskAnalyzer {
   /**
    * Analyze historical patterns
    */
-  async analyzeHistory(text) {
+  async analyzeHistory(text: string): Promise<HistoricalAnalysis> {
     if (!this.taskHistory) {
       return { confidence: 0, patterns: [] }
     }
 
     // Find similar tasks in history
-    const similar = this.taskHistory.filter(task => {
-      const similarity = this.calculateTextSimilarity(text, task.description)
+    const similar = this.taskHistory.filter((task) => {
+      const similarity = this.calculateTextSimilarity(text, task.description || '')
       return similarity > 0.5
     })
 
@@ -129,20 +170,19 @@ class TaskAnalyzer {
     }
 
     // Find most common domain for similar tasks
-    const domainCounts = {}
-    similar.forEach(task => {
+    const domainCounts: Record<string, number> = {}
+    similar.forEach((task) => {
       if (task.domain) {
         domainCounts[task.domain] = (domainCounts[task.domain] || 0) + 1
       }
     })
 
-    const mostCommon = Object.entries(domainCounts)
-      .sort((a, b) => b[1] - a[1])[0]
+    const mostCommon = Object.entries(domainCounts).sort((a, b) => b[1] - a[1])[0]
 
     return {
       confidence: mostCommon ? mostCommon[1] / similar.length : 0,
-      patterns: similar.map(t => ({ domain: t.domain, description: t.description })),
-      suggestedDomain: mostCommon ? mostCommon[0] : null
+      patterns: similar.map((t) => ({ domain: t.domain || '', description: t.description || '' })),
+      suggestedDomain: mostCommon ? mostCommon[0] : null,
     }
   }
 
@@ -151,7 +191,7 @@ class TaskAnalyzer {
    * AGENTIC: Claude uses templates/analysis/complexity.md for real estimation
    * This returns default - Claude determines actual complexity
    */
-  estimateComplexity(text) {
+  estimateComplexity(text: string): string {
     // AGENTIC: Return default, Claude analyzes via templates/analysis/complexity.md
     return 'medium'
   }
@@ -164,7 +204,7 @@ class TaskAnalyzer {
    * - Basic intent detection
    * Claude decides actual domain based on project context.
    */
-  selectPrimaryDomain(semantic, historical) {
+  selectPrimaryDomain(semantic: SemanticAnalysis, historical: HistoricalAnalysis): string {
     // Priority: historical > default
     if (historical && historical.suggestedDomain && historical.confidence > 0.7) {
       return historical.suggestedDomain
@@ -182,7 +222,7 @@ class TaskAnalyzer {
   /**
    * Calculate confidence based on available signals
    */
-  calculateConfidence(semantic, historical) {
+  calculateConfidence(semantic: SemanticAnalysis, historical: HistoricalAnalysis): number {
     let confidence = 0.5 // Base confidence
 
     // Boost from historical patterns
@@ -201,8 +241,8 @@ class TaskAnalyzer {
   /**
    * Build human-readable reason
    */
-  buildReason(primaryDomain, semantic, historical) {
-    const parts = []
+  buildReason(primaryDomain: string, semantic: SemanticAnalysis, historical: HistoricalAnalysis): string {
+    const parts: string[] = []
 
     if (historical && historical.suggestedDomain && historical.confidence > 0.7) {
       parts.push(`Historical: similar tasks used ${primaryDomain}`)
@@ -218,21 +258,21 @@ class TaskAnalyzer {
   /**
    * Load task history from memory
    */
-  async loadTaskHistory() {
+  async loadTaskHistory(): Promise<void> {
     try {
-      const memoryPath = pathManager.getFilePath(this.projectId, 'memory', 'context.jsonl')
+      const memoryPath = pathManager.getFilePath(this.projectId!, 'memory', 'context.jsonl')
       const content = await fs.readFile(memoryPath, 'utf-8')
       const lines = content.split('\n').filter(Boolean)
 
       this.taskHistory = lines
-        .map(line => {
+        .map((line) => {
           try {
-            return JSON.parse(line)
+            return JSON.parse(line) as HistoryEntry
           } catch {
             return null
           }
         })
-        .filter(entry => entry && entry.type === 'task_start' && entry.domain)
+        .filter((entry): entry is HistoryEntry => entry !== null && entry.type === 'task_start' && !!entry.domain)
         .slice(-100) // Last 100 tasks
     } catch {
       this.taskHistory = []
@@ -242,16 +282,15 @@ class TaskAnalyzer {
   /**
    * Calculate text similarity (simple Jaccard)
    */
-  calculateTextSimilarity(text1, text2) {
+  calculateTextSimilarity(text1: string, text2: string): number {
     const words1 = new Set(text1.toLowerCase().split(/\s+/))
     const words2 = new Set(text2.toLowerCase().split(/\s+/))
 
-    const intersection = new Set([...words1].filter(w => words2.has(w)))
+    const intersection = new Set([...words1].filter((w) => words2.has(w)))
     const union = new Set([...words1, ...words2])
 
     return intersection.size / union.size
   }
 }
 
-module.exports = TaskAnalyzer
-
+export default TaskAnalyzer

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

@@ -0,0 +1,19 @@
+/**
+ * Task Stack Manager - Handles multiple concurrent tasks with pause/resume capability
+ * Enables natural workflow with interruptions and context switching
+ */
+
+export type {
+  TaskEntry,
+  ParsedNowFile,
+  MigrationResult,
+  SwitchResult,
+  StackSummary,
+} from './types'
+
+export { parseNowFile, formatDuration } from './parser'
+export { ensureStackFile, appendToStack, readStack, writeStack, updateNowFile } from './storage'
+export { TaskStack } from './task-stack'
+
+import { TaskStack } from './task-stack'
+export default TaskStack

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

@@ -0,0 +1,86 @@
+/**
+ * Task Stack Parser
+ * Parsing utilities for now.md files
+ */
+
+import type { ParsedNowFile } from './types'
+
+/**
+ * Parse legacy now.md format
+ */
+export function parseNowFile(content: string): ParsedNowFile {
+  const result: ParsedNowFile = {
+    description: '',
+    started: null,
+    agent: null,
+    complexity: null,
+    dev: null,
+  }
+
+  // Check for frontmatter
+  if (content.startsWith('---')) {
+    const frontmatterEnd = content.indexOf('---', 3)
+    if (frontmatterEnd > 0) {
+      const frontmatter = content.substring(3, frontmatterEnd)
+      const lines = frontmatter.split('\n')
+
+      for (const line of lines) {
+        if (line.includes('task:')) {
+          result.description = line.split('task:')[1].trim().replace(/['"]/g, '')
+        }
+        if (line.includes('started:')) {
+          result.started = line.split('started:')[1].trim()
+        }
+        if (line.includes('agent:')) {
+          result.agent = line.split('agent:')[1].trim()
+        }
+        if (line.includes('complexity:')) {
+          result.complexity = line.split('complexity:')[1].trim()
+        }
+        if (line.includes('dev:')) {
+          result.dev = line.split('dev:')[1].trim()
+        }
+      }
+
+      // Get description from content if not in frontmatter
+      if (!result.description) {
+        const contentBody = content.substring(frontmatterEnd + 3).trim()
+        const firstLine = contentBody.split('\n')[0]
+        if (firstLine && !firstLine.startsWith('#')) {
+          result.description = firstLine.replace(/^[*-]\s*/, '').trim()
+        }
+      }
+    }
+  } else {
+    // No frontmatter, try to extract task from content
+    const lines = content.split('\n')
+    for (const line of lines) {
+      if (line.trim() && !line.startsWith('#') && !line.startsWith('---')) {
+        result.description = line.replace(/^[*-]\s*/, '').trim()
+        break
+      }
+    }
+  }
+
+  return result
+}
+
+/**
+ * Format duration in human-readable format
+ */
+export function formatDuration(ms: number): string {
+  const seconds = Math.floor(ms / 1000)
+  const minutes = Math.floor(seconds / 60)
+  const hours = Math.floor(minutes / 60)
+  const days = Math.floor(hours / 24)
+
+  if (days > 0) {
+    return `${days}d ${hours % 24}h`
+  } else if (hours > 0) {
+    return `${hours}h ${minutes % 60}m`
+  } else if (minutes > 0) {
+    return `${minutes}m`
+  } else {
+    return `${seconds}s`
+  }
+}

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

@@ -0,0 +1,123 @@
+/**
+ * Task Stack Storage
+ * File operations for task stack
+ */
+
+import fs from 'fs/promises'
+import log from '../../utils/logger'
+import type { TaskEntry } from './types'
+
+/**
+ * Ensure stack file exists
+ */
+export async function ensureStackFile(stackPath: string): Promise<void> {
+  try {
+    await fs.access(stackPath)
+  } catch {
+    // Create empty file
+    await fs.writeFile(stackPath, '')
+  }
+}
+
+/**
+ * Append entry to stack
+ */
+export async function appendToStack(stackPath: string, entry: TaskEntry): Promise<void> {
+  await ensureStackFile(stackPath)
+  const line = JSON.stringify(entry) + '\n'
+  await fs.appendFile(stackPath, line)
+}
+
+/**
+ * Read all stack entries
+ */
+export async function readStack(stackPath: string): Promise<TaskEntry[]> {
+  await ensureStackFile(stackPath)
+  const content = await fs.readFile(stackPath, 'utf8')
+
+  if (!content.trim()) {
+    return []
+  }
+
+  const entries: TaskEntry[] = []
+  const lines = content.split('\n').filter((line) => line.trim())
+
+  for (const line of lines) {
+    try {
+      entries.push(JSON.parse(line))
+    } catch (error) {
+      log.error('Error parsing stack line:', (error as Error).message)
+    }
+  }
+
+  return entries
+}
+
+/**
+ * Write full stack to file
+ */
+export async function writeStack(stackPath: string, stack: TaskEntry[]): Promise<void> {
+  const content = stack.map((task) => JSON.stringify(task)).join('\n') + '\n'
+  await fs.writeFile(stackPath, content)
+}
+
+/**
+ * Generate now.md content for a task
+ */
+export function generateNowContent(task: TaskEntry | null, customContent: string | null, formatDuration: (ms: number) => string): string {
+  if (customContent !== undefined && customContent !== null) {
+    return customContent
+  }
+
+  if (!task) {
+    return `# Current Task
+
+**No active task**
+
+Use \`/p:work\` or \`/p:resume\` to start working.
+
+---
+
+_Track your focus with \`/p:work [task]\`_
+`
+  }
+
+  const started = new Date(task.started)
+  const now = new Date()
+  const elapsed = formatDuration(now.getTime() - started.getTime() - (task.pausedDuration || 0))
+
+  return `---
+task: "${task.task}"
+started: ${task.started}
+agent: ${task.agent}
+complexity: ${task.complexity}
+dev: ${task.dev}
+---
+
+# Current Task
+
+**${task.task}**
+
+- Started: ${started.toLocaleTimeString()} (${elapsed} ago)
+- Agent: ${task.agent}
+- Complexity: ${task.complexity}
+
+---
+
+When done: \`/p:done\`
+Need to pause: \`/p:pause\`
+`
+}
+
+/**
+ * Update now.md file
+ */
+export async function updateNowFile(
+  nowPath: string,
+  task: TaskEntry | null,
+  customContent: string | null,
+  formatDuration: (ms: number) => string
+): Promise<void> {
+  const content = generateNowContent(task, customContent, formatDuration)
+  await fs.writeFile(nowPath, content)
+}