@miphamai/cli 0.16.5 → 0.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.16.5",
+  "version": "0.18.0",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",

package/src/agent/agent-context.ts

@@ -5,6 +5,7 @@ import { homedir } from 'node:os'
 import { ContextManager } from '../core/context'
 import type { ToolDefinition } from '../shared/index.ts'
 import type { AgentDefinition } from './types'
+import { AgentExperience } from './agent-experience'
 
 export interface AgentContextResult {
   context: ContextManager
@@ -31,28 +32,96 @@ function loadAgentMemory(agentName: string, scope: 'user' | 'project' | 'local')
       break
   }
 
-  if (!existsSync(memoryDir)) return ''
+  // Load static memory files
+  let staticMemory = ''
+  if (existsSync(memoryDir)) {
+    try {
+      const files = readdirSync(memoryDir).filter((f) => f.endsWith('.md'))
+      if (files.length > 0) {
+        const contents: string[] = []
+        for (const file of files.slice(0, 10)) {
+          try {
+            const content = readFileSync(join(memoryDir, file), 'utf-8').trim()
+            if (content) contents.push(content)
+          } catch {
+            // skip unreadable
+          }
+        }
+        if (contents.length > 0) {
+          staticMemory = [`[Agent Memory — ${scope} scope]`, ...contents].join('\n\n')
+        }
+      }
+    } catch {
+      // memory dir unreadable
+    }
+  }
 
-  try {
-    const files = readdirSync(memoryDir).filter((f) => f.endsWith('.md'))
-    if (files.length === 0) return ''
+  // Load auto-accumulated experience (always from user scope)
+  const exp = new AgentExperience(agentName)
+  const experienceContent = exp.getExperience()
 
-    const contents: string[] = []
-    for (const file of files.slice(0, 10)) {
-      // max 10 files
-      try {
-        const content = readFileSync(join(memoryDir, file), 'utf-8').trim()
-        if (content) contents.push(content)
-      } catch {
-        // skip unreadable
-      }
+  let experienceMemory = ''
+  if (experienceContent) {
+    const lines = experienceContent.split('\n')
+    const statsIdx = lines.findIndex((l) => l.startsWith('## Stats'))
+    const successIdx = lines.findIndex((l) => l.startsWith('## Success Patterns'))
+    const failureIdx = lines.findIndex((l) => l.startsWith('## Failure Patterns'))
+
+    // Header: content before the first section
+    const firstSection = Math.min(
+      successIdx !== -1 ? successIdx : Infinity,
+      failureIdx !== -1 ? failureIdx : Infinity,
+      statsIdx !== -1 ? statsIdx : Infinity,
+    )
+    const header = lines.slice(0, firstSection === Infinity ? 3 : firstSection)
+
+    // Last 5 success entries (summary line only, not detail)
+    const successLines: string[] = []
+    if (successIdx !== -1) {
+      const endIdx = Math.min(
+        failureIdx !== -1 && failureIdx > successIdx ? failureIdx : Infinity,
+        statsIdx !== -1 && statsIdx > successIdx ? statsIdx : Infinity,
+      )
+      successLines.push(
+        ...lines
+          .slice(successIdx + 1, endIdx === Infinity ? undefined : endIdx)
+          .filter((l) => l.startsWith('- ['))
+          .slice(-5),
+      )
     }
 
-    if (contents.length === 0) return ''
-    return [`[Agent Memory — ${scope} scope]`, ...contents].join('\n\n')
-  } catch {
-    return ''
+    // Last 3 failure entries (summary line only, not detail)
+    const failureLines: string[] = []
+    if (failureIdx !== -1) {
+      const endIdx = statsIdx !== -1 && statsIdx > failureIdx ? statsIdx : Infinity
+      failureLines.push(
+        ...lines
+          .slice(failureIdx + 1, endIdx === Infinity ? undefined : endIdx)
+          .filter((l) => l.startsWith('- ['))
+          .slice(-3),
+      )
+    }
+
+    // Stats section (header + stat line)
+    const stats = statsIdx !== -1 ? lines.slice(statsIdx, statsIdx + 3) : []
+
+    if (successLines.length > 0 || failureLines.length > 0) {
+      experienceMemory = [
+        '## Agent Experience',
+        ...header.filter((l) => l.trim()),
+        ...successLines,
+        ...failureLines,
+        ...stats,
+      ].join('\n')
+    }
+  }
+
+  // Combine both memory sources
+  if (staticMemory && experienceMemory) {
+    return `${staticMemory}\n\n---\n\n${experienceMemory}`
   }
+  if (experienceMemory) return experienceMemory
+  return staticMemory
 }
 
 /**

package/src/agent/agent-experience.ts

@@ -0,0 +1,105 @@
+import { mkdirSync, readFileSync, writeFileSync, existsSync, unlinkSync } from 'node:fs'
+import { join } from 'node:path'
+
+const MAX_EXPERIENCES = 20
+
+export class AgentExperience {
+  private readonly expFile: string
+  private readonly expDir: string
+
+  constructor(
+    private readonly agentName: string,
+    baseDir: string = join(process.env.HOME || '~', '.mipham', 'agent-memory'),
+  ) {
+    this.expDir = join(baseDir, agentName)
+    this.expFile = join(this.expDir, 'experience.md')
+  }
+
+  logSuccess(description: string, whenToApply: string): void {
+    const date = new Date().toISOString().slice(0, 10)
+    const entry = `- [${date}] ${description}\n  **When to apply:** ${whenToApply}\n`
+    this.appendToSection('## Success Patterns', entry, 'success')
+  }
+
+  logFailure(description: string, whenToAvoid: string): void {
+    const date = new Date().toISOString().slice(0, 10)
+    const entry = `- [${date}] ${description}\n  **When to avoid:** ${whenToAvoid}\n`
+    this.appendToSection('## Failure Patterns', entry, 'failure')
+  }
+
+  getExperience(): string {
+    if (!existsSync(this.expFile)) return ''
+    try {
+      return readFileSync(this.expFile, 'utf-8')
+    } catch {
+      return ''
+    }
+  }
+
+  reset(): void {
+    if (existsSync(this.expFile)) {
+      try {
+        unlinkSync(this.expFile)
+      } catch {
+        /* ok */
+      }
+    }
+  }
+
+  private appendToSection(section: string, entry: string, type: 'success' | 'failure'): void {
+    mkdirSync(this.expDir, { recursive: true })
+
+    let content = this.getExperience()
+    if (!content) {
+      content = `# Agent Experience — ${this.agentName}\n\n## Success Patterns\n\n## Failure Patterns\n\n## Stats\n- 总执行: 0 次 | 成功: 0 | 失败: 0\n`
+    }
+
+    // Find section and append entry
+    const sectionIndex = content.indexOf(section)
+    if (sectionIndex === -1) {
+      // Section missing — add before Stats
+      const statsIndex = content.indexOf('## Stats')
+      if (statsIndex !== -1) {
+        content =
+          content.slice(0, statsIndex) + `${section}\n${entry}\n` + content.slice(statsIndex)
+      } else {
+        content += `\n${section}\n${entry}\n`
+      }
+    } else {
+      // Find next section header after this one
+      const nextSection = content.indexOf('\n## ', sectionIndex + section.length)
+      const insertAt = nextSection !== -1 ? nextSection : content.length
+      content = content.slice(0, insertAt) + entry + content.slice(insertAt)
+    }
+
+    // Trim old entries if over limit
+    const lines = content.split('\n')
+    let finalEntries = lines.filter((l) => l.startsWith('- ['))
+    while (finalEntries.length > MAX_EXPERIENCES) {
+      // Remove oldest entry (first one found)
+      const firstEntryIdx = lines.findIndex((l) => l.startsWith('- ['))
+      if (firstEntryIdx !== -1) {
+        const nextEntryLine = lines[firstEntryIdx + 1]
+        const removeCount = nextEntryLine?.startsWith('  **') ? 2 : 1
+        lines.splice(firstEntryIdx, removeCount)
+        finalEntries = lines.filter((l) => l.startsWith('- ['))
+      } else {
+        break
+      }
+    }
+    content = lines.join('\n')
+
+    // Update stats (merged from incrementStat — single file write)
+    content = content.replace(
+      /- 总执行: (\d+) 次 \| 成功: (\d+) \| 失败: (\d+)/,
+      (_match, total: string, success: string, failure: string) => {
+        const newTotal = parseInt(total) + 1
+        const newSuccess = type === 'success' ? parseInt(success) + 1 : parseInt(success)
+        const newFailure = type === 'failure' ? parseInt(failure) + 1 : parseInt(failure)
+        return `- 总执行: ${newTotal} 次 | 成功: ${newSuccess} | 失败: ${newFailure}`
+      },
+    )
+
+    writeFileSync(this.expFile, content, 'utf-8')
+  }
+}

package/src/agent/sub-agent.ts

@@ -6,6 +6,7 @@ import { getBackgroundAgentRegistry } from './background-registry'
 import { getMessageBus } from './message-bus'
 import type { HookEngine } from '../core/hooks'
 import type { PermissionSystem } from '../core/permission'
+import { AgentExperience } from './agent-experience'
 
 const TYPE_SYSTEM_PROMPTS: Record<SubAgentType, string> = {
   general: 'You are a focused sub-agent. Complete the assigned task thoroughly and return results.',
@@ -73,6 +74,17 @@ export class SubAgent {
             task.result || task.error,
           )
         }
+        // Auto-log agent experience for background tasks
+        if (task.status === 'completed') {
+          this.logSuccessExperience(agentType, description, task.result || '', options.agentDef)
+        } else {
+          this.logFailureExperience(
+            agentType,
+            description,
+            task.error || 'Unknown error',
+            options.agentDef,
+          )
+        }
       })
 
       return `[background-task:${taskId}]`
@@ -84,6 +96,7 @@ export class SubAgent {
       if (this.hookEngine) {
         await this.hookEngine.executeSubagentStop(agentType, description, 'sub-agent', true, result)
       }
+      this.logSuccessExperience(agentType, description, result, options.agentDef)
       return result
     } catch (err) {
       if (this.hookEngine) {
@@ -95,6 +108,7 @@ export class SubAgent {
           String(err),
         )
       }
+      this.logFailureExperience(agentType, description, String(err), options.agentDef)
       throw err
     }
   }
@@ -314,4 +328,46 @@ export class SubAgent {
 
     return chunks.join('')
   }
+
+  /**
+   * Log a successful execution to AgentExperience.
+   * Wrapped in try/catch so it never breaks agent execution.
+   */
+  private logSuccessExperience(
+    agentType: SubAgentType,
+    description: string,
+    result: string,
+    agentDef?: AgentDefinition,
+  ): void {
+    try {
+      const name = agentDef?.name || agentType
+      const exp = new AgentExperience(name)
+      if (result && result.trim()) {
+        const firstLine = result.trim().split('\n')[0]?.slice(0, 150) || 'Task completed'
+        exp.logSuccess(firstLine, description)
+      }
+    } catch {
+      // Never let experience logging break execution
+    }
+  }
+
+  /**
+   * Log a failed execution to AgentExperience.
+   * Wrapped in try/catch so it never breaks agent execution.
+   */
+  private logFailureExperience(
+    agentType: SubAgentType,
+    description: string,
+    errMsg: string,
+    agentDef?: AgentDefinition,
+  ): void {
+    try {
+      const name = agentDef?.name || agentType
+      const exp = new AgentExperience(name)
+      const truncated = errMsg.slice(0, 200)
+      exp.logFailure(truncated, description)
+    } catch {
+      // Never let experience logging break execution
+    }
+  }
 }

package/src/commands/keys.ts

@@ -0,0 +1,94 @@
+import type { CommandHandler } from '../ui/commands'
+import { KeyManager } from '../config/keys-manager'
+
+export const keysCmd: CommandHandler = async (_ctx, args) => {
+  const manager = new KeyManager()
+  const sub = args[0]?.toLowerCase()
+
+  // /keys rotate <provider>
+  if (sub === 'rotate') {
+    const provider = args[1]
+    if (!provider) {
+      return {
+        content: 'Usage: /keys rotate <provider>\n\nExample: /keys rotate deepseek',
+      }
+    }
+    // Interactive: prompt user to provide new key via follow-up chat message
+    return {
+      content: [
+        '── Key Rotation ──',
+        '',
+        `Provider: ${provider}`,
+        '',
+        'To complete rotation, the new API key must be provided.',
+        'Type your new key in chat and the AI will handle rotation securely.',
+        '',
+        'The old key will be backed up to ~/.mipham/keys/<provider>.backup (chmod 600).',
+      ].join('\n'),
+      forwardToAI: `The user wants to rotate the API key for provider "${provider}". Ask them to provide the new key value, then:
+1. Call KeyManager.rotate("${provider}", newKey) with the provided key
+2. The new key should be stored in ~/.mipham/config.json (or appropriate config)
+3. Confirm rotation count and backup location
+4. Remind them the old key is backed up at ~/.mipham/keys/${provider}.backup`,
+    }
+  }
+
+  // /keys audit
+  if (sub === 'audit') {
+    const expired = manager.audit()
+    if (expired.length === 0) {
+      return {
+        content:
+          '── Key Audit ──\n\n✅ All keys are within the 90-day rotation window.\n\nNo expired keys found.',
+      }
+    }
+
+    const lines: string[] = [
+      '── Key Audit ──',
+      '',
+      `⚠️  ${expired.length} key(s) have exceeded the 90-day rotation threshold:`,
+      '',
+      ...expired.map(
+        (k) =>
+          `  🔴 ${k.provider.padEnd(16)} ${k.ageDays} days since last rotation (${k.lastRotated.slice(0, 10)})`,
+      ),
+      '',
+      'Rotate expired keys with: /keys rotate <provider>',
+    ]
+    return { content: lines.join('\n') }
+  }
+
+  // /keys (list)
+  const keys = manager.list()
+
+  if (keys.length === 0) {
+    return {
+      content: [
+        '── API Keys ──',
+        '',
+        'No API keys tracked yet.',
+        '',
+        'Keys are tracked in ~/.mipham/keys.json when you configure providers.',
+        'Use /keys rotate <provider> to begin tracking rotation for a provider.',
+      ].join('\n'),
+    }
+  }
+
+  const lines: string[] = [
+    '── API Keys ──',
+    '',
+    'Provider         Age     Rotations   Status',
+    '─'.repeat(55),
+    ...keys.map((k) => {
+      const status = k.expired ? '🔴 EXPIRED' : '🟢 OK'
+      return `  ${k.provider.padEnd(16)} ${String(k.ageDays).padStart(4)}d   ${String(k.rotationCount).padStart(5)}       ${status}`
+    }),
+    '',
+    `${keys.length} key(s) tracked.`,
+    '',
+    'Commands:',
+    '  /keys rotate <provider>  — rotate a key',
+    '  /keys audit             — check for expired keys',
+  ]
+  return { content: lines.join('\n') }
+}

package/src/config/keys-manager.ts

@@ -0,0 +1,121 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+import { homedir } from 'node:os'
+
+const MIPHAM_DIR = join(homedir(), '.mipham')
+const KEYS_FILE = join(MIPHAM_DIR, 'keys.json')
+
+export interface KeyEntry {
+  createdAt: string
+  lastRotated: string
+  rotationCount: number
+  provider: string
+}
+
+export interface KeyStatus {
+  provider: string
+  createdAt: string
+  lastRotated: string
+  rotationCount: number
+  ageDays: number
+  expired: boolean
+}
+
+export interface KeysData {
+  [provider: string]: KeyEntry
+}
+
+function loadKeys(): KeysData {
+  if (!existsSync(KEYS_FILE)) return {}
+  try {
+    const raw = readFileSync(KEYS_FILE, 'utf-8')
+    return JSON.parse(raw) as KeysData
+  } catch {
+    return {}
+  }
+}
+
+function saveKeys(data: KeysData): void {
+  mkdirSync(dirname(KEYS_FILE), { recursive: true })
+  const tmp = KEYS_FILE + '.tmp'
+  writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 })
+  writeFileSync(KEYS_FILE, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 })
+  try {
+    chmodSync(KEYS_FILE, 0o600)
+  } catch {
+    // chmod on Windows is a no-op
+  }
+}
+
+function daysSince(iso: string): number {
+  const then = new Date(iso).getTime()
+  const now = Date.now()
+  return Math.floor((now - then) / (1000 * 60 * 60 * 24))
+}
+
+export class KeyManager {
+  list(): KeyStatus[] {
+    const data = loadKeys()
+    return Object.entries(data).map(([provider, entry]) => ({
+      provider,
+      createdAt: entry.createdAt,
+      lastRotated: entry.lastRotated,
+      rotationCount: entry.rotationCount,
+      ageDays: daysSince(entry.lastRotated),
+      expired: daysSince(entry.lastRotated) > 90,
+    }))
+  }
+
+  rotate(provider: string, _newKey: string): { success: boolean; message: string } {
+    const data = loadKeys()
+    const now = new Date().toISOString()
+    const existing = data[provider]
+
+    // Backup old entry if it exists
+    if (existing) {
+      const backupDir = join(MIPHAM_DIR, 'keys')
+      mkdirSync(backupDir, { recursive: true })
+      const backupPath = join(backupDir, `${provider}.backup`)
+      writeFileSync(backupPath, JSON.stringify(existing, null, 2) + '\n', { mode: 0o600 })
+      try {
+        chmodSync(backupPath, 0o600)
+      } catch {
+        // Windows
+      }
+
+      data[provider] = {
+        createdAt: existing.createdAt,
+        lastRotated: now,
+        rotationCount: existing.rotationCount + 1,
+        provider,
+      }
+    } else {
+      data[provider] = {
+        createdAt: now,
+        lastRotated: now,
+        rotationCount: 1,
+        provider,
+      }
+    }
+
+    saveKeys(data)
+    return {
+      success: true,
+      message: `Key for "${provider}" rotated (rotation #${data[provider]!.rotationCount}). Backup saved to ~/.mipham/keys/${provider}.backup`,
+    }
+  }
+
+  audit(): KeyStatus[] {
+    return this.list().filter((k) => k.expired)
+  }
+
+  getExpiryReminder(): string | null {
+    const expired = this.audit()
+    if (expired.length === 0) return null
+
+    const lines = expired.map(
+      (k) => `  - ${k.provider}: last rotated ${k.ageDays} days ago (90-day threshold exceeded)`,
+    )
+    return `⚠️  API key rotation overdue:\n${lines.join('\n')}\n\nRun /keys rotate <provider> to rotate.`
+  }
+}