@miphamai/cli 0.4.0 → 0.5.1

package/src/core/hooks.ts

@@ -4,8 +4,23 @@ import type {
   HookContext,
   HookResult,
   ToolResult,
+  HookConfig,
 } from '../shared/index.ts'
 
+/**
+ * Merge two permission decisions, keeping the more restrictive one.
+ * Priority: deny > defer > ask > allow
+ */
+export function mergePermissionDecision(
+  current: HookResult['permissionDecision'],
+  incoming: NonNullable<HookResult['permissionDecision']>,
+): HookResult['permissionDecision'] {
+  const priority: Record<string, number> = { deny: 3, defer: 2, ask: 1, allow: 0 }
+  const currScore = current ? (priority[current] ?? 0) : -1
+  const incScore = priority[incoming] ?? 0
+  return incScore > currScore ? incoming : current
+}
+
 export class HookEngine {
   private hooks: HookDefinition[] = []
 
@@ -19,18 +34,14 @@ export class HookEngine {
     )
   }
 
+  // ── Existing event executors ──
+
   async executePreToolUse(
     toolName: string,
     toolInput: Record<string, unknown>,
     sessionId: string,
   ): Promise<HookResult> {
-    const ctx: HookContext = {
-      event: 'PreToolUse',
-      toolName,
-      toolInput,
-      sessionId,
-    }
-
+    const ctx: HookContext = { event: 'PreToolUse', toolName, toolInput, sessionId }
     return this.runHooks('PreToolUse', toolName, ctx)
   }
 
@@ -40,45 +51,64 @@ export class HookEngine {
     toolResult: ToolResult,
     sessionId: string,
   ): Promise<HookResult> {
-    const ctx: HookContext = {
-      event: 'PostToolUse',
-      toolName,
-      toolInput,
-      toolResult,
-      sessionId,
-    }
-
+    const ctx: HookContext = { event: 'PostToolUse', toolName, toolInput, toolResult, sessionId }
     return this.runHooks('PostToolUse', toolName, ctx)
   }
 
   async executeSessionStart(sessionId: string): Promise<HookResult> {
-    const ctx: HookContext = {
-      event: 'SessionStart',
-      sessionId,
-    }
-
+    const ctx: HookContext = { event: 'SessionStart', sessionId }
     return this.runHooks('SessionStart', undefined, ctx)
   }
 
   async executeSessionEnd(sessionId: string): Promise<HookResult> {
-    const ctx: HookContext = {
-      event: 'SessionEnd',
-      sessionId,
-    }
-
+    const ctx: HookContext = { event: 'SessionEnd', sessionId }
     return this.runHooks('SessionEnd', undefined, ctx)
   }
 
   async executeNotification(message: string, sessionId: string): Promise<HookResult> {
+    const ctx: HookContext = { event: 'Notification', sessionId, toolInput: { message } }
+    return this.runHooks('Notification', undefined, ctx)
+  }
+
+  // ── NEW event executors ──
+
+  /** Stop hook: fires when AI completes a turn. Can block to force continuation. */
+  async executeStop(sessionId: string): Promise<HookResult> {
+    const ctx: HookContext = { event: 'Stop', sessionId }
+    return this.runHooks('Stop', undefined, ctx)
+  }
+
+  /** UserPromptSubmit: fires when user submits input. Can block malicious input. */
+  async executeUserPromptSubmit(prompt: string, sessionId: string): Promise<HookResult> {
+    const ctx: HookContext = { event: 'UserPromptSubmit', sessionId, userPrompt: prompt }
+    return this.runHooks('UserPromptSubmit', undefined, ctx)
+  }
+
+  /** PreCompact: fires before context compaction. */
+  async executePreCompact(sessionId: string): Promise<HookResult> {
+    const ctx: HookContext = { event: 'PreCompact', sessionId }
+    return this.runHooks('PreCompact', undefined, ctx)
+  }
+
+  /** PostCompact: fires after context compaction. Can inject additional context. */
+  async executePostCompact(sessionId: string): Promise<HookResult> {
+    const ctx: HookContext = { event: 'PostCompact', sessionId }
+    return this.runHooks('PostCompact', undefined, ctx)
+  }
+
+  /** ConfigChange: fires when configuration changes. */
+  async executeConfigChange(key: string, value: unknown, sessionId: string): Promise<HookResult> {
     const ctx: HookContext = {
-      event: 'Notification',
+      event: 'ConfigChange',
       sessionId,
-      toolInput: { message },
+      configKey: key,
+      configValue: value,
     }
-
-    return this.runHooks('Notification', undefined, ctx)
+    return this.runHooks('ConfigChange', undefined, ctx)
   }
 
+  // ── Core execution ──
+
   private async runHooks(
     event: HookEvent,
     toolName: string | undefined,
@@ -93,15 +123,45 @@ export class HookEngine {
     for (const hook of matching) {
       try {
         const hookResult = await hook.handler(ctx)
+
+        // Block on first deny — stops further hook execution
         if (!hookResult.allowed) {
-          return hookResult // Block on first deny
+          return { ...hookResult }
+        }
+
+        // Merge permission decisions (deny > defer > ask > allow)
+        if (hookResult.permissionDecision) {
+          result.permissionDecision = mergePermissionDecision(
+            result.permissionDecision,
+            hookResult.permissionDecision,
+          )
+        }
+
+        // Stop hook: block decision takes precedence
+        if (hookResult.decision === 'block') {
+          result.decision = 'block'
+          result.reason = hookResult.reason || result.reason
         }
+
+        // Merge modified inputs
         if (hookResult.modifiedInput) {
           result.modifiedInput = {
             ...(result.modifiedInput || {}),
             ...hookResult.modifiedInput,
           }
         }
+
+        // Collect additional context from multiple hooks
+        if (hookResult.additionalContext) {
+          result.additionalContext = result.additionalContext
+            ? result.additionalContext + '\n' + hookResult.additionalContext
+            : hookResult.additionalContext
+        }
+
+        // PostToolUse: replace output if provided
+        if (hookResult.updatedOutput) {
+          result.updatedOutput = hookResult.updatedOutput
+        }
       } catch {
         // Hook failures do not block execution
       }

package/src/core/instructions.ts

@@ -21,6 +21,7 @@ function parseFrontmatter(raw: string): FrontmatterResult {
 
 export class InstructionsLoader {
   private instructions: InstructionFile[] = []
+  private skillsReminder = ''
 
   loadAll(cwd: string): void {
     this.instructions = []
@@ -60,9 +61,19 @@ export class InstructionsLoader {
       parts.push(`<!-- ${levelLabel[inst.level] || inst.level} (${inst.path}) -->\n${inst.content}`)
     }
 
+    // Append skills reminder after all instructions
+    if (this.skillsReminder) {
+      parts.push(this.skillsReminder)
+    }
+
     return parts.join('\n\n---\n\n')
   }
 
+  /** Set the skills system-reminder block to inject into the system prompt. */
+  setSkillsReminder(reminder: string): void {
+    this.skillsReminder = reminder
+  }
+
   list(): InstructionFile[] {
     return [...this.instructions]
   }

package/src/core/memory/memory-loader.ts

@@ -0,0 +1,23 @@
+import { MemoryManager } from './memory-manager'
+import type { MemoryManager as MemoryManagerType } from './memory-manager'
+
+const MEMORY_DIR = `${process.env.HOME || '~'}/.mipham/memory`
+
+let instance: MemoryManagerType | null = null
+
+export function getMemoryManager(): MemoryManagerType {
+  if (!instance) {
+    instance = new MemoryManager(MEMORY_DIR)
+    instance.loadAll()
+  }
+  return instance
+}
+
+/**
+ * Load relevant memories for the current session and inject as
+ * a system-reminder block. Called at SessionStart.
+ */
+export function loadSessionMemories(context: string): string {
+  const mm = getMemoryManager()
+  return mm.buildSystemReminder(context)
+}

package/src/core/memory/memory-manager.ts

@@ -0,0 +1,192 @@
+import {
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+  existsSync,
+} from 'node:fs'
+import { join, extname } from 'node:path'
+
+export interface MemoryMetadata {
+  type: 'user' | 'feedback' | 'project' | 'reference'
+  relevance: string[]
+}
+
+export interface MemoryEntry {
+  name: string
+  description: string
+  metadata: MemoryMetadata
+  content: string
+  filePath: string
+  updatedAt: Date
+}
+
+const INDEX_FILE = 'MEMORY.md'
+
+export class MemoryManager {
+  private memories = new Map<string, MemoryEntry>()
+
+  constructor(private memoryDir: string) {
+    mkdirSync(memoryDir, { recursive: true })
+  }
+
+  loadAll(): void {
+    this.memories.clear()
+    if (!existsSync(this.memoryDir)) return
+
+    let entries: string[] = []
+    try {
+      entries = readdirSync(this.memoryDir)
+    } catch {
+      return
+    }
+
+    for (const entry of entries) {
+      if (entry === INDEX_FILE || extname(entry) !== '.md') continue
+      const filePath = join(this.memoryDir, entry)
+      try {
+        const raw = readFileSync(filePath, 'utf-8')
+        const parsed = this.parseMemoryFile(raw, filePath)
+        if (parsed) {
+          this.memories.set(parsed.name, parsed)
+        }
+      } catch {
+        // skip unparseable
+      }
+    }
+  }
+
+  write(name: string, content: string, metadata: MemoryMetadata): void {
+    const fileName = `${name}.md`
+    const filePath = join(this.memoryDir, fileName)
+
+    const body = this.formatMemoryFile(name, metadata, content)
+    writeFileSync(filePath, body, 'utf-8')
+
+    const entry: MemoryEntry = {
+      name,
+      description: metadata.relevance.join(', '),
+      metadata,
+      content,
+      filePath,
+      updatedAt: new Date(),
+    }
+
+    this.memories.set(name, entry)
+    this.updateIndex()
+  }
+
+  recall(context: string, limit: number = 10): MemoryEntry[] {
+    const contextLower = context.toLowerCase()
+    const scored: Array<{ entry: MemoryEntry; score: number }> = []
+
+    for (const entry of this.memories.values()) {
+      let score = 0
+      // Match against relevance tags
+      for (const tag of entry.metadata.relevance) {
+        if (contextLower.includes(tag.toLowerCase())) score += 3
+      }
+      // Match against content keywords
+      const contentWords = entry.content.toLowerCase().split(/\s+/)
+      const contextWords = new Set(contextLower.split(/\s+/))
+      for (const word of contentWords) {
+        if (contextWords.has(word) && word.length > 3) score += 1
+      }
+      if (score > 0) {
+        scored.push({ entry, score })
+      }
+    }
+
+    scored.sort((a, b) => b.score - a.score)
+    return scored.slice(0, limit).map((s) => s.entry)
+  }
+
+  delete(name: string): void {
+    const entry = this.memories.get(name)
+    if (!entry) return
+
+    try {
+      unlinkSync(entry.filePath)
+    } catch {
+      // file may already be gone
+    }
+    this.memories.delete(name)
+    this.updateIndex()
+  }
+
+  buildSystemReminder(context: string, maxTokens: number = 5000): string {
+    const relevant = this.recall(context, 10)
+    if (relevant.length === 0) return ''
+
+    const lines: string[] = ['<system-reminder>', 'Relevant memories from previous sessions:']
+
+    let tokenBudget = 50 // opening tags
+    for (const entry of relevant) {
+      const line = `- ${entry.name}: ${entry.content.slice(0, 200)}`
+      const lineTokens = Math.ceil(line.length / 4)
+      if (tokenBudget + lineTokens > maxTokens) break
+      lines.push(line)
+      tokenBudget += lineTokens
+    }
+
+    lines.push('</system-reminder>')
+    return lines.join('\n')
+  }
+
+  private updateIndex(): void {
+    const lines: string[] = [
+      '# Memory Index',
+      '',
+      `_Last updated: ${new Date().toISOString()}_`,
+      '',
+    ]
+
+    for (const entry of this.memories.values()) {
+      lines.push(`- [${entry.name}](${entry.name}.md) — ${entry.description}`)
+    }
+
+    writeFileSync(join(this.memoryDir, INDEX_FILE), lines.join('\n') + '\n', 'utf-8')
+  }
+
+  private parseMemoryFile(raw: string, filePath: string): MemoryEntry | null {
+    const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/)
+    if (!match) return null
+
+    const frontmatter = match[1] || ''
+    const content = (match[2] || '').trim()
+
+    // Parse simple YAML-like frontmatter
+    const nameMatch = frontmatter.match(/name:\s*(\S+)/)
+    const descMatch = frontmatter.match(/description:\s*(.+)/)
+    const typeMatch = frontmatter.match(/type:\s*(\S+)/)
+    const relevanceMatch = frontmatter.match(/relevance:\s*\[(.+)\]/)
+
+    if (!nameMatch) return null
+
+    return {
+      name: nameMatch[1]!,
+      description: descMatch?.[1]?.trim() || '',
+      metadata: {
+        type: (typeMatch?.[1] as MemoryMetadata['type']) || 'reference',
+        relevance: relevanceMatch?.[1]?.split(',').map((s) => s.trim()) || [],
+      },
+      content,
+      filePath,
+      updatedAt: new Date(),
+    }
+  }
+
+  private formatMemoryFile(name: string, metadata: MemoryMetadata, content: string): string {
+    return `---
+name: ${name}
+description: ${metadata.relevance.join(', ')}
+metadata:
+  type: ${metadata.type}
+  relevance: [${metadata.relevance.join(', ')}]
+---
+
+${content}
+`
+  }
+}

package/src/core/memory/memory-writer.ts

@@ -0,0 +1,72 @@
+import type { MemoryManager } from './memory-manager'
+
+const MEMORY_TRIGGERS = [
+  {
+    pattern: /(?:以后|今后|从现在开始|always|from now on|记住|remember)\s*[：:]\s*(.+)/i,
+    type: 'user' as const,
+  },
+  {
+    pattern: /(?:偏好|prefer|preference|习惯)\s*[：:]\s*(.+)/i,
+    type: 'user' as const,
+  },
+  {
+    pattern: /(?:项目|project)\s+(?:使用|uses?|采用)\s+(.+)/i,
+    type: 'project' as const,
+  },
+  {
+    pattern: /(?:决策|decided?|决定)\s*[：:]\s*(.+)/i,
+    type: 'project' as const,
+  },
+]
+
+/**
+ * Analyze the user's message for memory-worthy content and persist it.
+ */
+export function analyzeForMemory(userMessage: string, memoryManager: MemoryManager): void {
+  for (const trigger of MEMORY_TRIGGERS) {
+    const match = userMessage.match(trigger.pattern)
+    if (match?.[1]) {
+      const content = match[1].trim()
+      const name = `auto-${trigger.type}-${Date.now()}`
+      const relevance = extractKeywords(content)
+
+      memoryManager.write(name, content, {
+        type: trigger.type === 'user' ? 'user' : 'project',
+        relevance,
+      })
+    }
+  }
+}
+
+function extractKeywords(text: string): string[] {
+  // Simple keyword extraction: words > 3 chars, no stop words
+  const stopWords = new Set([
+    'this',
+    'that',
+    'with',
+    'from',
+    'have',
+    'been',
+    'were',
+    'they',
+    'will',
+    'would',
+    'could',
+    'should',
+    'about',
+    'which',
+    'their',
+    '使用',
+    '以后',
+    '现在',
+    '可以',
+    '需要',
+    '不要',
+    '应该',
+    '已经',
+  ])
+  return text
+    .split(/\s+/)
+    .filter((w) => w.length > 3 && !stopWords.has(w.toLowerCase()))
+    .slice(0, 5)
+}

package/src/core/permission-config.ts

@@ -0,0 +1,34 @@
+import type { PermissionConfig, PermissionMode } from '../shared/index.ts'
+
+const DEFAULT_CONFIG: PermissionConfig = {
+  mode: 'default',
+  allow: [],
+  deny: [],
+}
+
+/**
+ * Load permission configuration from a settings object.
+ * Merges with defaults for missing fields.
+ */
+export function loadPermissionConfig(raw: Partial<PermissionConfig> = {}): PermissionConfig {
+  return {
+    mode: (raw.mode as PermissionMode) || DEFAULT_CONFIG.mode,
+    allow: Array.isArray(raw.allow) ? raw.allow : [...DEFAULT_CONFIG.allow],
+    deny: Array.isArray(raw.deny) ? raw.deny : [...DEFAULT_CONFIG.deny],
+  }
+}
+
+/** Valid mode transition order for Shift+Tab cycling. */
+export const MODE_CYCLE: PermissionMode[] = [
+  'default',
+  'acceptEdits',
+  'plan',
+  'auto',
+  'dontAsk',
+  'bypassPermissions',
+]
+
+export function nextMode(current: PermissionMode): PermissionMode {
+  const idx = MODE_CYCLE.indexOf(current)
+  return MODE_CYCLE[(idx + 1) % MODE_CYCLE.length]!
+}

package/src/core/permission-rules.ts

@@ -0,0 +1,66 @@
+import type { PermissionRuleEntry } from '../shared/index.ts'
+
+/**
+ * Match a Bash(command_pattern) rule against an actual tool call.
+ *
+ * Pattern formats:
+ *   "Bash"              → matches any Bash call
+ *   "Bash(git:*)"       → matches "git status", "git diff --cached", etc.
+ *   "Bash(npm test:*)"  → matches "npm test -- --coverage"
+ *   "Write(/etc/*)"     → matches Write to /etc/passwd, /etc/hosts, etc.
+ */
+export function matchBashRule(
+  pattern: string,
+  toolName: string,
+  toolInput: Record<string, unknown>,
+): boolean {
+  // Check if pattern has a parenthesized sub-pattern
+  const parenMatch = pattern.match(/^(\w+)\((.+)\)$/)
+  if (!parenMatch) {
+    // Plain tool name match: "Bash", "Write"
+    return toolName === pattern
+  }
+
+  const [, baseTool, subPattern] = parenMatch
+
+  if (toolName !== baseTool!) return false
+
+  // For Bash: match against the command string
+  if (baseTool === 'Bash') {
+    const cmd = String(toolInput.command || '')
+    return wildcardMatch(subPattern!, cmd.trim())
+  }
+
+  // For Write/Edit: match against the file_path
+  if (baseTool === 'Write' || baseTool === 'Edit') {
+    const path = String(toolInput.file_path || '')
+    return wildcardMatch(subPattern!, path)
+  }
+
+  return false
+}
+
+export function wildcardMatch(pattern: string, input: string): boolean {
+  const regexStr =
+    '^' +
+    pattern
+      .replace(/[.+^${}()|[\]\\*?]/g, '\\$&') // escape regex specials (incl. * and ?)
+      .replace(/:/g, '[:\\s]') // : → match colon or whitespace
+      .replace(/\\\*/g, '.*') // * → .*
+      .replace(/\\\?/g, '.') + // ? → .
+    '$'
+  return new RegExp(regexStr).test(input)
+}
+
+/** Compile a rule pattern string into a PermissionRuleEntry. */
+export function compileRule(pattern: string, level: 'allow' | 'deny' | 'ask'): PermissionRuleEntry {
+  const regexStr =
+    '^' +
+    pattern
+      .replace(/[.+^${}()|[\]\\*?]/g, '\\$&')
+      .replace(/:/g, '[:\\s]')
+      .replace(/\\\*/g, '.*')
+      .replace(/\\\?/g, '.') +
+    '$'
+  return { pattern, level, compiled: new RegExp(regexStr) }
+}