prjct-cli 0.11.5 → 0.12.0

package/core/agentic/memory-system/types.ts

@@ -0,0 +1,159 @@
+/**
+ * Memory System Types and Constants
+ *
+ * This module provides types for the memory system that tracks
+ * user preferences, decisions, and learned patterns.
+ */
+
+/**
+ * Semantic tags for memory categorization.
+ * Use these constants instead of raw strings.
+ */
+export const MEMORY_TAGS = {
+  // Code preferences
+  CODE_STYLE: 'code_style',
+  NAMING_CONVENTION: 'naming_convention',
+  FILE_STRUCTURE: 'file_structure',
+
+  // Workflow preferences
+  COMMIT_STYLE: 'commit_style',
+  BRANCH_NAMING: 'branch_naming',
+  TEST_BEHAVIOR: 'test_behavior',
+  SHIP_WORKFLOW: 'ship_workflow',
+
+  // Project context
+  TECH_STACK: 'tech_stack',
+  ARCHITECTURE: 'architecture',
+  DEPENDENCIES: 'dependencies',
+
+  // User preferences
+  OUTPUT_VERBOSITY: 'output_verbosity',
+  CONFIRMATION_LEVEL: 'confirmation_level',
+  AGENT_PREFERENCE: 'agent_preference',
+} as const
+
+export type MemoryTag = typeof MEMORY_TAGS[keyof typeof MEMORY_TAGS]
+
+/**
+ * A single memory entry.
+ */
+export interface Memory {
+  id: string
+  title: string
+  content: string
+  tags: MemoryTag[]
+  userTriggered: boolean
+  createdAt: string
+  updatedAt: string
+}
+
+/**
+ * Memory database structure.
+ */
+export interface MemoryDatabase {
+  version: number
+  memories: Memory[]
+  /** Index of tag -> memory IDs */
+  index: Record<MemoryTag, string[]>
+}
+
+/**
+ * A history entry from session logs.
+ */
+export interface HistoryEntry {
+  /** Timestamp */
+  ts: string
+  /** Event type */
+  type: HistoryEventType
+  /** Command that triggered this event */
+  command?: string
+  /** Task description */
+  task?: string
+  /** Feature name */
+  feature?: string
+  /** Duration if applicable */
+  duration?: string
+  /** Success status */
+  success?: boolean
+  /** Error message if failed */
+  error?: string
+}
+
+export type HistoryEventType =
+  | 'task_started'
+  | 'task_completed'
+  | 'task_paused'
+  | 'task_resumed'
+  | 'feature_added'
+  | 'feature_shipped'
+  | 'idea_captured'
+  | 'command_executed'
+  | 'error_occurred'
+
+/**
+ * A tracked decision and its frequency.
+ */
+export interface Decision {
+  value: string
+  count: number
+  firstSeen: string
+  lastSeen: string
+  confidence: 'low' | 'medium' | 'high'
+  contexts: string[]
+}
+
+/**
+ * A tracked workflow pattern.
+ */
+export interface Workflow {
+  /** Times this workflow was executed */
+  count: number
+  firstSeen: string
+  lastSeen: string
+  /** Average duration */
+  avgDuration?: string
+  /** Success rate (0-1) */
+  successRate?: number
+  /** Steps in the workflow */
+  steps?: string[]
+}
+
+/**
+ * A user preference value.
+ */
+export interface Preference {
+  value: string | number | boolean
+  updatedAt: string
+}
+
+/**
+ * Aggregated patterns learned from history.
+ */
+export interface Patterns {
+  version: number
+  decisions: Record<string, Decision>
+  preferences: Record<string, Preference>
+  workflows: Record<string, Workflow>
+  counters: Record<string, number>
+}
+
+/**
+ * Context passed to memory system operations.
+ */
+export interface MemoryContext {
+  /** Command being executed */
+  commandName?: string
+  /** Command parameters */
+  params?: MemoryContextParams
+  /** Project path */
+  projectPath?: string
+  /** Current task */
+  currentTask?: string
+}
+
+export interface MemoryContextParams {
+  task?: string
+  description?: string
+  feature?: string
+  idea?: string
+}

package/core/agentic/memory-system.ts

@@ -0,0 +1,8 @@
+/**
+ * Memory System
+ * Re-exports from memory-system/index.ts for backwards compatibility.
+ */
+
+import memorySystem from './memory-system/index'
+export default memorySystem
+export { MemorySystem, MEMORY_TAGS } from './memory-system/index'

package/core/agentic/parallel-tools.ts

@@ -0,0 +1,165 @@
+/**
+ * Parallel Tools
+ * Execute multiple tools in parallel for performance
+ *
+ * @module agentic/parallel-tools
+ * @version 1.0.0
+ */
+
+import fs from 'fs/promises'
+
+interface ToolCall {
+  tool: string
+  args: unknown[]
+}
+
+interface ToolResult {
+  tool: string
+  success: boolean
+  result?: unknown
+  error?: string
+  duration: number
+}
+
+interface ParallelMetrics {
+  totalCalls: number
+  parallelCalls: number
+  sequentialCalls: number
+  averageDuration: number
+  savedTime: number
+}
+
+class ParallelTools {
+  private metrics: ParallelMetrics
+
+  constructor() {
+    this.metrics = {
+      totalCalls: 0,
+      parallelCalls: 0,
+      sequentialCalls: 0,
+      averageDuration: 0,
+      savedTime: 0,
+    }
+  }
+
+  /**
+   * Execute multiple tool calls in parallel
+   */
+  async execute(toolCalls: ToolCall[]): Promise<ToolResult[]> {
+    const startTime = Date.now()
+
+    const promises = toolCalls.map(async (call) => {
+      const callStart = Date.now()
+      try {
+        const result = await this.executeOne(call.tool, call.args)
+        return {
+          tool: call.tool,
+          success: true,
+          result,
+          duration: Date.now() - callStart,
+        }
+      } catch (error) {
+        return {
+          tool: call.tool,
+          success: false,
+          error: (error as Error).message,
+          duration: Date.now() - callStart,
+        }
+      }
+    })
+
+    const results = await Promise.all(promises)
+
+    // Update metrics
+    const totalDuration = Date.now() - startTime
+    const sumIndividual = results.reduce((sum, r) => sum + r.duration, 0)
+    this.metrics.totalCalls += toolCalls.length
+    this.metrics.parallelCalls += toolCalls.length
+    this.metrics.savedTime += sumIndividual - totalDuration
+    this.metrics.averageDuration =
+      (this.metrics.averageDuration * (this.metrics.totalCalls - toolCalls.length) + totalDuration) /
+      this.metrics.totalCalls
+
+    return results
+  }
+
+  /**
+   * Execute a single tool
+   */
+  private async executeOne(tool: string, args: unknown[]): Promise<unknown> {
+    switch (tool) {
+      case 'Read':
+        return await fs.readFile(args[0] as string, 'utf-8')
+
+      case 'Write':
+        await fs.writeFile(args[0] as string, args[1] as string, 'utf-8')
+        return true
+
+      case 'GetTimestamp':
+        return new Date().toISOString()
+
+      case 'GetDate':
+        return new Date().toISOString().split('T')[0]
+
+      default:
+        throw new Error(`Unknown tool: ${tool}`)
+    }
+  }
+
+  /**
+   * Read multiple files in parallel
+   */
+  async readAll(paths: string[]): Promise<Map<string, string | null>> {
+    const results = new Map<string, string | null>()
+
+    const promises = paths.map(async (path) => {
+      try {
+        const content = await fs.readFile(path, 'utf-8')
+        return { path, content }
+      } catch {
+        return { path, content: null }
+      }
+    })
+
+    const readResults = await Promise.all(promises)
+
+    readResults.forEach(({ path, content }) => {
+      results.set(path, content)
+    })
+
+    return results
+  }
+
+  /**
+   * Check if tools can be parallelized
+   */
+  canParallelize(tools: string[]): boolean {
+    // Read operations can always be parallelized
+    const readOnlyTools = ['Read', 'Glob', 'Grep', 'GetTimestamp', 'GetDate']
+    return tools.every((tool) => readOnlyTools.includes(tool))
+  }
+
+  /**
+   * Get parallelization metrics
+   */
+  getMetrics(): ParallelMetrics {
+    return { ...this.metrics }
+  }
+
+  /**
+   * Reset metrics
+   */
+  resetMetrics(): void {
+    this.metrics = {
+      totalCalls: 0,
+      parallelCalls: 0,
+      sequentialCalls: 0,
+      averageDuration: 0,
+      savedTime: 0,
+    }
+  }
+}
+
+const parallelTools = new ParallelTools()
+export default parallelTools
+export { ParallelTools }

package/core/agentic/plan-mode/approval.ts

@@ -0,0 +1,57 @@
+/**
+ * Plan Mode Approval Prompts
+ */
+
+import type { ApprovalPrompt, ApprovalContext } from './types'
+
+/**
+ * Generate approval prompt for destructive commands
+ */
+export function generateApprovalPrompt(commandName: string, context: ApprovalContext): ApprovalPrompt {
+  const prompts: Record<string, ApprovalPrompt> = {
+    ship: {
+      title: 'Ship Confirmation',
+      message: 'Ready to commit and push changes?',
+      details: [
+        `Branch: ${context.branch || 'current'}`,
+        `Files: ${context.changedFiles?.length || 0} changed`,
+        `Commit: "${context.commitMessage || 'No message'}"`,
+      ],
+      options: [
+        { key: 'y', label: 'Yes, ship it', action: 'approve' },
+        { key: 'n', label: 'No, cancel', action: 'reject' },
+        { key: 'e', label: 'Edit message', action: 'edit' },
+      ],
+    },
+    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`],
+      options: [
+        { key: 'y', label: 'Yes, cleanup', action: 'approve' },
+        { key: 'n', label: 'No, cancel', action: 'reject' },
+        { key: 'l', label: 'List files first', action: 'list' },
+      ],
+    },
+    git: {
+      title: 'Git Operation Confirmation',
+      message: `Execute: ${context.operation || 'git operation'}?`,
+      details: context.warnings || [],
+      options: [
+        { key: 'y', label: 'Yes, execute', action: 'approve' },
+        { key: 'n', label: 'No, cancel', action: 'reject' },
+      ],
+    },
+  }
+
+  return (
+    prompts[commandName] || {
+      title: 'Confirmation Required',
+      message: `Execute ${commandName}?`,
+      options: [
+        { key: 'y', label: 'Yes', action: 'approve' },
+        { key: 'n', label: 'No', action: 'reject' },
+      ],
+    }
+  )
+}

package/core/agentic/plan-mode/constants.ts

@@ -0,0 +1,44 @@
+/**
+ * Plan Mode Constants
+ */
+
+/**
+ * Commands that require planning mode
+ */
+export const PLAN_REQUIRED_COMMANDS = [
+  'feature', // New features need planning
+  'spec', // Specs are planning by definition
+  'design', // Architecture needs planning
+  'refactor', // Refactoring needs impact analysis
+  'migrate', // Migrations are high-risk
+]
+
+/**
+ * Commands that are destructive and need approval
+ */
+export const DESTRUCTIVE_COMMANDS = [
+  'ship', // Commits and pushes
+  'cleanup', // Deletes files/code
+  'git', // Git operations
+  'migrate', // Database/schema changes
+]
+
+/**
+ * Read-only tools allowed in planning mode
+ */
+export const PLANNING_TOOLS = ['Read', 'Glob', 'Grep', 'GetTimestamp', 'GetDate', 'GetDateTime']
+
+/**
+ * Plan status enum
+ */
+export const PLAN_STATUS = {
+  GATHERING: 'gathering', // Collecting information
+  ANALYZING: 'analyzing', // Understanding context
+  PROPOSING: 'proposing', // Generating plan
+  PENDING_APPROVAL: 'pending', // Waiting for user
+  APPROVED: 'approved', // User approved
+  REJECTED: 'rejected', // User rejected
+  EXECUTING: 'executing', // Running the plan
+  COMPLETED: 'completed', // Done
+  ABORTED: 'aborted', // User stopped mid-execution
+}

package/core/agentic/plan-mode/index.ts

@@ -0,0 +1,28 @@
+/**
+ * Plan Mode System
+ *
+ * P3.4: Plan Mode + Approval Flow
+ * Separates planning from execution for better user confidence.
+ *
+ * Pattern from: Devin AI, Windsurf, Kiro
+ */
+
+export type {
+  PlanParams,
+  GatheredInfo,
+  ProposedPlan,
+  PlanStep,
+  Plan,
+  ApprovalPrompt,
+  ApprovalContext,
+} from './types'
+
+export { PLAN_STATUS, PLAN_REQUIRED_COMMANDS, DESTRUCTIVE_COMMANDS, PLANNING_TOOLS } from './constants'
+export { generateApprovalPrompt } from './approval'
+export { PlanMode } from './plan-mode'
+
+import { PlanMode } from './plan-mode'
+
+// Export singleton
+const planMode = new PlanMode()
+export default planMode