prjct-cli 0.11.4 → 0.12.0

package/core/agentic/memory-system/semantic-memories.ts

@@ -0,0 +1,277 @@
+/**
+ * Semantic Memories
+ * P3.3: Tagged, searchable, CRUD memory operations.
+ */
+
+import fs from 'fs/promises'
+import path from 'path'
+import pathManager from '../../infrastructure/path-manager'
+import type { Memory, MemoryDatabase, Context } from './types'
+import { MEMORY_TAGS } from './types'
+
+export class SemanticMemories {
+  private _memories: MemoryDatabase | null = null
+  private _memoriesLoaded: boolean = false
+
+  private _getMemoriesPath(projectId: string): string {
+    return path.join(pathManager.getGlobalProjectPath(projectId), 'memory', 'memories.json')
+  }
+
+  async loadMemories(projectId: string): Promise<MemoryDatabase> {
+    if (this._memoriesLoaded && this._memories) {
+      return this._memories
+    }
+
+    try {
+      const memoriesPath = this._getMemoriesPath(projectId)
+      const content = await fs.readFile(memoriesPath, 'utf-8')
+      this._memories = JSON.parse(content)
+      this._memoriesLoaded = true
+      return this._memories!
+    } catch {
+      this._memories = {
+        version: 1,
+        memories: [],
+        index: {},
+      }
+      this._memoriesLoaded = true
+      return this._memories
+    }
+  }
+
+  async saveMemories(projectId: string): Promise<void> {
+    if (!this._memories) return
+
+    const memoriesPath = this._getMemoriesPath(projectId)
+    await fs.mkdir(path.dirname(memoriesPath), { recursive: true })
+    await fs.writeFile(memoriesPath, JSON.stringify(this._memories, null, 2), 'utf-8')
+  }
+
+  async createMemory(
+    projectId: string,
+    {
+      title,
+      content,
+      tags = [],
+      userTriggered = false,
+    }: { title: string; content: string; tags?: string[]; userTriggered?: boolean }
+  ): Promise<string> {
+    const db = await this.loadMemories(projectId)
+
+    const memory: Memory = {
+      id: `mem_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      title,
+      content,
+      tags,
+      userTriggered,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    }
+
+    db.memories.push(memory)
+
+    for (const tag of tags) {
+      if (!db.index[tag]) db.index[tag] = []
+      db.index[tag].push(memory.id)
+    }
+
+    await this.saveMemories(projectId)
+    return memory.id
+  }
+
+  async updateMemory(
+    projectId: string,
+    memoryId: string,
+    updates: { title?: string; content?: string; tags?: string[] }
+  ): Promise<boolean> {
+    const db = await this.loadMemories(projectId)
+
+    const index = db.memories.findIndex((m) => m.id === memoryId)
+    if (index === -1) return false
+
+    const memory = db.memories[index]
+    const oldTags = memory.tags || []
+
+    if (updates.title) memory.title = updates.title
+    if (updates.content) memory.content = updates.content
+    if (updates.tags) {
+      for (const tag of oldTags) {
+        if (db.index[tag]) {
+          db.index[tag] = db.index[tag].filter((id) => id !== memoryId)
+        }
+      }
+      for (const tag of updates.tags) {
+        if (!db.index[tag]) db.index[tag] = []
+        db.index[tag].push(memoryId)
+      }
+      memory.tags = updates.tags
+    }
+
+    memory.updatedAt = new Date().toISOString()
+    await this.saveMemories(projectId)
+    return true
+  }
+
+  async deleteMemory(projectId: string, memoryId: string): Promise<boolean> {
+    const db = await this.loadMemories(projectId)
+
+    const index = db.memories.findIndex((m) => m.id === memoryId)
+    if (index === -1) return false
+
+    const memory = db.memories[index]
+
+    for (const tag of memory.tags || []) {
+      if (db.index[tag]) {
+        db.index[tag] = db.index[tag].filter((id) => id !== memoryId)
+      }
+    }
+
+    db.memories.splice(index, 1)
+    await this.saveMemories(projectId)
+    return true
+  }
+
+  async findByTags(projectId: string, tags: string[], matchAll: boolean = false): Promise<Memory[]> {
+    const db = await this.loadMemories(projectId)
+
+    if (matchAll) {
+      return db.memories.filter((m) => tags.every((tag) => (m.tags || []).includes(tag)))
+    } else {
+      const matchingIds = new Set<string>()
+      for (const tag of tags) {
+        const ids = db.index[tag] || []
+        ids.forEach((id) => matchingIds.add(id))
+      }
+      return db.memories.filter((m) => matchingIds.has(m.id))
+    }
+  }
+
+  async searchMemories(projectId: string, query: string): Promise<Memory[]> {
+    const db = await this.loadMemories(projectId)
+    const queryLower = query.toLowerCase()
+
+    return db.memories.filter(
+      (m) => m.title.toLowerCase().includes(queryLower) || m.content.toLowerCase().includes(queryLower)
+    )
+  }
+
+  async getRelevantMemories(projectId: string, context: Context, limit: number = 5): Promise<Memory[]> {
+    const db = await this.loadMemories(projectId)
+
+    const scored = db.memories.map((memory) => {
+      let score = 0
+
+      const contextTags = this._extractContextTags(context)
+      for (const tag of memory.tags || []) {
+        if (contextTags.includes(tag)) score += 10
+      }
+
+      const age = Date.now() - new Date(memory.updatedAt).getTime()
+      const daysSinceUpdate = age / (1000 * 60 * 60 * 24)
+      score += Math.max(0, 5 - daysSinceUpdate)
+
+      if (memory.userTriggered) score += 5
+
+      const keywords = this._extractKeywords(context)
+      for (const keyword of keywords) {
+        if (memory.content.toLowerCase().includes(keyword)) score += 2
+        if (memory.title.toLowerCase().includes(keyword)) score += 3
+      }
+
+      return { ...memory, _score: score }
+    })
+
+    return scored
+      .filter((m) => m._score > 0)
+      .sort((a, b) => b._score - a._score)
+      .slice(0, limit)
+      .map(({ _score, ...memory }) => memory as Memory)
+  }
+
+  private _extractContextTags(context: Context): string[] {
+    const tags: string[] = []
+
+    const commandTags: Record<string, string[]> = {
+      ship: [MEMORY_TAGS.COMMIT_STYLE, MEMORY_TAGS.SHIP_WORKFLOW, MEMORY_TAGS.TEST_BEHAVIOR],
+      feature: [MEMORY_TAGS.ARCHITECTURE, MEMORY_TAGS.CODE_STYLE],
+      done: [MEMORY_TAGS.SHIP_WORKFLOW],
+      analyze: [MEMORY_TAGS.TECH_STACK, MEMORY_TAGS.ARCHITECTURE],
+      spec: [MEMORY_TAGS.ARCHITECTURE, MEMORY_TAGS.CODE_STYLE],
+    }
+
+    if (context.commandName && commandTags[context.commandName]) {
+      tags.push(...commandTags[context.commandName])
+    }
+
+    return tags
+  }
+
+  private _extractKeywords(context: Context): string[] {
+    const keywords: string[] = []
+
+    if (context.params?.description) {
+      keywords.push(...(context.params.description as string).toLowerCase().split(/\s+/))
+    }
+    if (context.params?.feature) {
+      keywords.push(...(context.params.feature as string).toLowerCase().split(/\s+/))
+    }
+
+    const stopWords = ['the', 'a', 'an', 'is', 'are', 'to', 'for', 'and', 'or', 'in']
+    return keywords.filter((k) => k.length > 2 && !stopWords.includes(k))
+  }
+
+  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],
+      test_before_ship: [MEMORY_TAGS.TEST_BEHAVIOR, MEMORY_TAGS.SHIP_WORKFLOW],
+      preferred_agent: [MEMORY_TAGS.AGENT_PREFERENCE],
+      code_style: [MEMORY_TAGS.CODE_STYLE],
+      verbosity: [MEMORY_TAGS.OUTPUT_VERBOSITY],
+    }
+
+    const tags = tagMap[decisionType] || []
+
+    const existing = await this.searchMemories(projectId, decisionType)
+    if (existing.length > 0) {
+      await this.updateMemory(projectId, existing[0].id, {
+        content: `${decisionType}: ${value}`,
+        tags,
+      })
+    } else {
+      await this.createMemory(projectId, {
+        title: `Preference: ${decisionType}`,
+        content: `${decisionType}: ${value}${context ? `\nContext: ${context}` : ''}`,
+        tags,
+        userTriggered: true,
+      })
+    }
+  }
+
+  async getAllMemories(projectId: string): Promise<Memory[]> {
+    const db = await this.loadMemories(projectId)
+    return db.memories
+  }
+
+  async getMemoryStats(projectId: string) {
+    const db = await this.loadMemories(projectId)
+
+    const tagCounts: Record<string, number> = {}
+    for (const [tag, ids] of Object.entries(db.index)) {
+      tagCounts[tag] = ids.length
+    }
+
+    return {
+      totalMemories: db.memories.length,
+      userTriggered: db.memories.filter((m) => m.userTriggered).length,
+      tagCounts,
+      oldestMemory: db.memories[0]?.createdAt,
+      newestMemory: db.memories[db.memories.length - 1]?.createdAt,
+    }
+  }
+
+  reset(): void {
+    this._memories = null
+    this._memoriesLoaded = false
+  }
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Session Memory - Tier 1
+ * Ephemeral, single command context.
+ */
+
+export class SessionStore {
+  private _sessionMemory: Map<string, { value: unknown; timestamp: number }> = new Map()
+
+  setSession(key: string, value: unknown): void {
+    this._sessionMemory.set(key, { value, timestamp: Date.now() })
+  }
+
+  getSession(key: string): unknown {
+    const entry = this._sessionMemory.get(key)
+    return entry?.value
+  }
+
+  clearSession(): void {
+    this._sessionMemory.clear()
+  }
+}

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' },
+      ],
+    }
+  )
+}