@miphamai/cli 0.22.0 → 0.24.0

package/README.md

@@ -16,7 +16,7 @@ Requirements: **Bun 1.2+** (recommended) or **Node.js 22+**
 ## Features
 
 - **9 AI Providers** — Anthropic Claude · OpenAI GPT · DeepSeek · Kimi (Moonshot) · Google Gemini · Doubao 豆包 · Tencent Hunyuan 混元 · Qwen 通义千问 · MiphamAI
-- **66 Slash Commands** — Interactive command picker (↑↓ Enter Esc), Claude Code-compatible, zero re-learning
+- **66 Slash Commands** — Interactive command picker (↑↓ Enter Esc), intuitive command interface, zero re-learning
 - **16 Built-in Tools** — File ops, shell execution, agent dispatch, MCP integration, web search
 - **14 Skills + Marketplace** — 11 standard + 3 Mipham-exclusive skills. `/browse-skills` `/install-skill` community marketplace
 - **Self-Update** — `mipham update` / `/upgrade` — one command to check, backup config, upgrade, restore. API keys preserved

package/package.json

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

package/skills/workflows/audit.js

@@ -10,37 +10,85 @@ export const meta = {
 }
 
 phase('Scope')
-const targets = args.targets || (await agent(
-  'List all source files that need security auditing. Return { files: [{ path, reason }] }',
-  { schema: { type: 'object', properties: { files: { type: 'array', items: { type: 'object', properties: { path: { type: 'string' }, reason: { type: 'string' } }, required: ['path', 'reason'] } } }, required: ['files'] } },
-)).files
+const targets =
+  args.targets ||
+  (
+    await agent(
+      'List all source files that need security auditing. Return { files: [{ path, reason }] }',
+      {
+        schema: {
+          type: 'object',
+          properties: {
+            files: {
+              type: 'array',
+              items: {
+                type: 'object',
+                properties: { path: { type: 'string' }, reason: { type: 'string' } },
+                required: ['path', 'reason'],
+              },
+            },
+          },
+          required: ['files'],
+        },
+      },
+    )
+  ).files
 
 log(`Auditing ${targets.length} files`)
 
 phase('Audit')
-const raw = (await pipeline(
-  targets,
-  t => agent(`Security audit ${t.path}: injection, auth, crypto, secrets, input validation. Return { findings: [{ severity, file, line, summary }] }`,
-    { label: `audit:${t.path}`, schema: { type: 'object', properties: { findings: { type: 'array', items: { type: 'object', properties: { severity: { type: 'string', enum: ['critical', 'high', 'medium', 'low'] }, file: { type: 'string' }, line: { type: 'number' }, summary: { type: 'string' } }, required: ['severity', 'file', 'summary'] } } }, required: ['findings'] } },
-  )),
+const raw = await pipeline(targets, (t) =>
+  agent(
+    `Security audit ${t.path}: injection, auth, crypto, secrets, input validation. Return { findings: [{ severity, file, line, summary }] }`,
+    {
+      label: `audit:${t.path}`,
+      schema: {
+        type: 'object',
+        properties: {
+          findings: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                severity: { type: 'string', enum: ['critical', 'high', 'medium', 'low'] },
+                file: { type: 'string' },
+                line: { type: 'number' },
+                summary: { type: 'string' },
+              },
+              required: ['severity', 'file', 'summary'],
+            },
+          },
+        },
+        required: ['findings'],
+      },
+    },
+  ),
 )
-const findings = raw.flatMap(r => (r && r.findings) || [])
+const findings = raw.flatMap((r) => (r && r.findings) || [])
 
 log(`Found ${findings.length} potential issues`)
 
 phase('Verify')
 const verified = await parallel(
-  findings.map(f => () =>
-    verify(f, {
-      mode: 'adversarial',
-      skeptics: 3,
-      threshold: 2,
-      schema: { type: 'object', properties: { real: { type: 'boolean' }, reason: { type: 'string' } }, required: ['real', 'reason'] },
-    })
+  findings.map(
+    (f) => () =>
+      verify(f, {
+        mode: 'adversarial',
+        skeptics: 3,
+        threshold: 2,
+        schema: {
+          type: 'object',
+          properties: { real: { type: 'boolean' }, reason: { type: 'string' } },
+          required: ['real', 'reason'],
+        },
+      }),
   ),
 )
 
-const confirmed = verified.filter(Boolean).filter(v => v.survives).map(v => v.finding)
+const confirmed = verified
+  .filter(Boolean)
+  .filter((v) => v.survives)
+  .map((v) => v.finding)
 log(`${confirmed.length}/${findings.length} findings verified`)
 
 phase('Report')

package/src/agent/agent-context.ts

@@ -5,7 +5,9 @@ import { homedir } from 'node:os'
 import { ContextManager } from '../core/context'
 import type { ToolDefinition } from '../shared/index.ts'
 import type { AgentDefinition } from './types'
+import type { CrsiConfig } from '../shared/index.ts'
 import { AgentExperience } from './agent-experience'
+import { ExperienceRuleExtractor } from './experience-rules.js'
 
 export interface AgentContextResult {
   context: ContextManager
@@ -15,8 +17,14 @@ export interface AgentContextResult {
 /**
  * Load agent memory files from the appropriate scope directory.
  * Returns combined content for injection into the system prompt.
+ *
+ * @param crsiRuleInjection — when false, skip experience rule extraction (CRSI feature flag).
  */
-function loadAgentMemory(agentName: string, scope: 'user' | 'project' | 'local'): string {
+function loadAgentMemory(
+  agentName: string,
+  scope: 'user' | 'project' | 'local',
+  crsiRuleInjection = true,
+): string {
   let memoryDir: string
   const home = homedir()
 
@@ -56,63 +64,16 @@ function loadAgentMemory(agentName: string, scope: 'user' | 'project' | 'local')
     }
   }
 
-  // Load auto-accumulated experience (always from user scope)
-  const exp = new AgentExperience(agentName)
-  const experienceContent = exp.getExperience()
-
+  // Load auto-accumulated experience rules (always from user scope)
+  // Gated by crsi.ruleInjection feature flag
   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),
-      )
-    }
-
-    // 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 (crsiRuleInjection) {
+    const exp = new AgentExperience(agentName)
+    const extractor = new ExperienceRuleExtractor()
+    const rules = extractor.prioritize(exp.getRules())
 
-    if (successLines.length > 0 || failureLines.length > 0) {
-      experienceMemory = [
-        '## Agent Experience',
-        ...header.filter((l) => l.trim()),
-        ...successLines,
-        ...failureLines,
-        ...stats,
-      ].join('\n')
+    if (rules.length > 0) {
+      experienceMemory = extractor.formatForInjection(rules)
     }
   }
 
@@ -139,6 +100,7 @@ export function createAgentContext(
   agentDef: AgentDefinition,
   toolRegistry: Map<string, ToolDefinition>,
   contextWindow?: number,
+  crsiConfig?: Partial<CrsiConfig>,
 ): AgentContextResult {
   // Create isolated context
   const context = new ContextManager({
@@ -149,7 +111,8 @@ export function createAgentContext(
   // Build system prompt with optional agent memory
   let systemPrompt = agentDef.systemPrompt
   if (agentDef.memory) {
-    const memory = loadAgentMemory(agentDef.name, agentDef.memory)
+    const ruleInjection = crsiConfig?.ruleInjection !== false
+    const memory = loadAgentMemory(agentDef.name, agentDef.memory, ruleInjection)
     if (memory) {
       systemPrompt = `${systemPrompt}\n\n---\n\n${memory}`
     }

package/src/agent/agent-experience.ts

@@ -1,5 +1,6 @@
 import { mkdirSync, readFileSync, writeFileSync, existsSync, unlinkSync } from 'node:fs'
 import { join } from 'node:path'
+import { ExperienceRuleExtractor, type ExperienceRule } from './experience-rules.js'
 
 const MAX_EXPERIENCES = 20
 
@@ -46,6 +47,13 @@ export class AgentExperience {
     }
   }
 
+  getRules(): ExperienceRule[] {
+    const content = this.getExperience()
+    if (!content) return []
+    const extractor = new ExperienceRuleExtractor()
+    return extractor.extract(content, this.agentName)
+  }
+
   private appendToSection(section: string, entry: string, type: 'success' | 'failure'): void {
     mkdirSync(this.expDir, { recursive: true })
 

package/src/agent/cross-session/discovery.ts

@@ -0,0 +1,99 @@
+import {
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+  existsSync,
+  mkdirSync,
+  unlinkSync,
+} from 'node:fs'
+import { join } from 'node:path'
+import { homedir, hostname } from 'node:os'
+import type { SessionInfo } from '../../shared/types'
+
+const MIPHAM_HOME = join(homedir(), '.mipham')
+const ACTIVE_SESSIONS_DIR = join(MIPHAM_HOME, '.active-sessions')
+
+/**
+ * Register the current session as active.
+ * Writes a SessionInfo JSON file + updates mtime for heartbeat.
+ */
+export function registerActiveSession(info: SessionInfo): void {
+  mkdirSync(ACTIVE_SESSIONS_DIR, { recursive: true })
+  const filePath = join(ACTIVE_SESSIONS_DIR, `${info.id}.json`)
+  writeFileSync(filePath, JSON.stringify(info, null, 2), 'utf-8')
+}
+
+/**
+ * Update heartbeat (mtime) for an active session.
+ */
+export function heartbeatSession(sessionId: string): void {
+  const filePath = join(ACTIVE_SESSIONS_DIR, `${sessionId}.json`)
+  if (existsSync(filePath)) {
+    // Touch the file by rewriting it
+    const raw = readFileSync(filePath, 'utf-8')
+    writeFileSync(filePath, raw, 'utf-8') // updates mtime
+  }
+}
+
+/**
+ * Unregister a session (called on shutdown).
+ */
+export function unregisterSession(sessionId: string): void {
+  const filePath = join(ACTIVE_SESSIONS_DIR, `${sessionId}.json`)
+  try {
+    if (existsSync(filePath)) unlinkSync(filePath)
+  } catch {
+    // Best-effort
+  }
+}
+
+/**
+ * Discover all active sessions.
+ * Reads ~/.mipham/.active-sessions/ directory.
+ */
+export function discoverSessions(): SessionInfo[] {
+  if (!existsSync(ACTIVE_SESSIONS_DIR)) return []
+
+  try {
+    const files = readdirSync(ACTIVE_SESSIONS_DIR).filter((f) => f.endsWith('.json'))
+
+    const sessions: SessionInfo[] = []
+    for (const file of files) {
+      try {
+        const raw = readFileSync(join(ACTIVE_SESSIONS_DIR, file), 'utf-8')
+        const info = JSON.parse(raw) as SessionInfo
+        sessions.push(info)
+      } catch {
+        // Skip corrupt files
+      }
+    }
+
+    // Sort by most recently active
+    sessions.sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime())
+    return sessions
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Create a SessionInfo for the current process.
+ */
+export function createSessionInfo(
+  sessionId: string,
+  name: string,
+  cwd?: string,
+  provider?: string,
+  model?: string,
+): SessionInfo {
+  return {
+    id: sessionId,
+    name,
+    machine: hostname(),
+    pid: process.pid,
+    startedAt: new Date().toISOString(),
+    cwd,
+    provider,
+    model,
+  }
+}

package/src/agent/cross-session/file-inbox.ts

@@ -0,0 +1,118 @@
+import {
+  mkdirSync,
+  writeFileSync,
+  readdirSync,
+  readFileSync,
+  unlinkSync,
+  existsSync,
+  renameSync,
+} from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+import type { CrossSessionTransport } from './transport'
+import type { AgentMessage } from '../message-bus'
+import type { SessionInfo } from '../../shared/types'
+
+const MIPHAM_HOME = join(homedir(), '.mipham')
+const INBOX_DIR = join(MIPHAM_HOME, 'inbox')
+
+/**
+ * Filesystem-based cross-session transport.
+ *
+ * Messages are stored as JSON files in ~/.mipham/inbox/<session-id>/.
+ * Each message file is named: <ISO-timestamp>-<msg-id>.json
+ */
+export class FileInboxTransport implements CrossSessionTransport {
+  private ensureDir(dir: string): void {
+    mkdirSync(dir, { recursive: true })
+  }
+
+  async send(from: SessionInfo, toSessionId: string, msg: AgentMessage): Promise<boolean> {
+    try {
+      const inboxDir = join(INBOX_DIR, toSessionId)
+      this.ensureDir(inboxDir)
+
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
+      const filename = `${timestamp}-${msg.id}.json`
+      const filePath = join(inboxDir, filename)
+
+      // Atomic write: temp file then rename
+      const tmpPath = filePath + '.tmp'
+      writeFileSync(
+        tmpPath,
+        JSON.stringify({ ...msg, _fromSession: from.id, _fromMachine: from.machine }, null, 2),
+        'utf-8',
+      )
+      renameSync(tmpPath, filePath)
+
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  async poll(sessionId: string): Promise<AgentMessage[]> {
+    const inboxDir = join(INBOX_DIR, sessionId)
+    if (!existsSync(inboxDir)) return []
+
+    try {
+      const files = readdirSync(inboxDir)
+        .filter((f) => f.endsWith('.json') && !f.endsWith('.tmp'))
+        .sort() // chronological by timestamp prefix
+
+      const messages: AgentMessage[] = []
+      for (const file of files) {
+        try {
+          const raw = readFileSync(join(inboxDir, file), 'utf-8')
+          const parsed = JSON.parse(raw) as AgentMessage & {
+            _fromSession?: string
+            _fromMachine?: string
+          }
+
+          // Build the message body with cross-session origin prefix
+          const originPrefix = parsed._fromSession
+            ? `[From: ${parsed._fromSession}@${parsed._fromMachine || 'unknown'}]\n\n`
+            : ''
+
+          messages.push({
+            id: parsed.id,
+            from: parsed.from,
+            to: parsed.to,
+            summary: parsed.summary,
+            message: `${originPrefix}${parsed.message}`,
+            timestamp: new Date(parsed.timestamp),
+            read: parsed.read,
+            type: parsed.type,
+          })
+
+          // Mark as read by deleting the file (read-once)
+          unlinkSync(join(inboxDir, file))
+        } catch {
+          // Skip corrupt files
+        }
+      }
+
+      return messages
+    } catch {
+      return []
+    }
+  }
+
+  async listSessions(): Promise<SessionInfo[]> {
+    return discoverSessions()
+  }
+}
+
+// Import discoverSessions lazily to avoid circular dependency
+import { discoverSessions } from './discovery'
+
+// ── Singleton ──
+
+let _transport: FileInboxTransport | null = null
+
+export function getFileInboxTransport(): FileInboxTransport {
+  if (!_transport) {
+    _transport = new FileInboxTransport()
+  }
+  return _transport
+}

package/src/agent/cross-session/transport.ts

@@ -0,0 +1,17 @@
+import type { AgentMessage } from '../message-bus'
+import type { SessionInfo } from '../../shared/types'
+
+/**
+ * Transport layer for cross-session messaging.
+ * Implementations can use filesystem, unix sockets, TCP, etc.
+ */
+export interface CrossSessionTransport {
+  /** Send a message to a destination session's inbox. Returns true on success. */
+  send(from: SessionInfo, toSessionId: string, msg: AgentMessage): Promise<boolean>
+
+  /** Poll for unread messages addressed to the given session. */
+  poll(sessionId: string): Promise<AgentMessage[]>
+
+  /** List all discoverable active sessions. */
+  listSessions(): Promise<SessionInfo[]>
+}

package/src/agent/effectiveness-tracker.ts

@@ -0,0 +1,149 @@
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+
+export interface RuleEffectiveness {
+  ruleId: string
+  appliedCount: number
+  successAfterCount: number
+  preRuleFailureRate: number
+  postRuleFailureRate: number
+  status: 'active' | 'degrading' | 'disabled'
+  createdAt: string
+  lastEvaluatedAt: string
+  evaluationHistory: Array<{
+    date: string
+    appliedCount: number
+    failureRate: number
+  }>
+}
+
+const EVAL_THRESHOLD = 10 // evaluate after 10 applications
+const STORE_FILE = 'effectiveness.json'
+
+export class EffectivenessTracker {
+  private data: Map<string, RuleEffectiveness>
+  private storePath: string
+
+  constructor(storeDir: string = join(process.env.HOME || '~', '.mipham', 'rule-engine')) {
+    this.storePath = join(storeDir, STORE_FILE)
+    this.data = new Map()
+  }
+
+  recordApplication(ruleId: string, success: boolean): void {
+    let eff = this.data.get(ruleId)
+    if (!eff) {
+      eff = {
+        ruleId,
+        appliedCount: 0,
+        successAfterCount: 0,
+        preRuleFailureRate: 1.0,
+        postRuleFailureRate: 0,
+        status: 'active',
+        createdAt: new Date().toISOString().slice(0, 10),
+        lastEvaluatedAt: '',
+        evaluationHistory: [],
+      }
+      this.data.set(ruleId, eff)
+    }
+
+    eff.appliedCount++
+    if (success) eff.successAfterCount++
+
+    // Calculate current failure rate
+    if (eff.appliedCount >= EVAL_THRESHOLD) {
+      eff.postRuleFailureRate = 1 - eff.successAfterCount / eff.appliedCount
+    }
+  }
+
+  /**
+   * Evaluate rule effectiveness and return auto-management actions.
+   *
+   * @param autoRuleManagement — when false, skip auto-degrade/disable/enable logic
+   *   but still record evaluation history for manual review. Default true.
+   */
+  evaluate(autoRuleManagement = true): {
+    upgrades: string[]
+    degradations: string[]
+    disables: string[]
+  } {
+    const result = {
+      upgrades: [] as string[],
+      degradations: [] as string[],
+      disables: [] as string[],
+    }
+    const now = new Date().toISOString().slice(0, 10)
+
+    for (const [ruleId, eff] of this.data) {
+      if (eff.appliedCount < EVAL_THRESHOLD) continue
+
+      eff.lastEvaluatedAt = now
+      eff.evaluationHistory.push({
+        date: now,
+        appliedCount: eff.appliedCount,
+        failureRate: eff.postRuleFailureRate,
+      })
+
+      // Keep max 10 history entries
+      if (eff.evaluationHistory.length > 10) {
+        eff.evaluationHistory = eff.evaluationHistory.slice(-10)
+      }
+
+      // Auto-management is gated by crsi.autoRuleManagement feature flag
+      if (!autoRuleManagement) continue
+
+      // Degrade: active rule with high failure rate
+      if (eff.status === 'active' && eff.postRuleFailureRate > 0.6) {
+        eff.status = 'degrading'
+        result.degradations.push(ruleId)
+      }
+
+      // Disable: degrading rule with no improvement across evaluations
+      if (eff.status === 'degrading' && eff.evaluationHistory.length >= 2) {
+        const last = eff.evaluationHistory[eff.evaluationHistory.length - 1]
+        const prev = eff.evaluationHistory[eff.evaluationHistory.length - 2]
+        if (last!.failureRate >= prev!.failureRate) {
+          eff.status = 'disabled'
+          result.disables.push(ruleId)
+        }
+      }
+
+      // Upgrade: degrading rule that has improved significantly
+      if (eff.status === 'degrading' && eff.postRuleFailureRate < 0.4) {
+        eff.status = 'active'
+        result.upgrades.push(ruleId)
+      }
+    }
+
+    return result
+  }
+
+  getEffectiveness(ruleId: string): RuleEffectiveness | null {
+    return this.data.get(ruleId) || null
+  }
+
+  persist(): void {
+    const dir = dirname(this.storePath)
+    mkdirSync(dir, { recursive: true })
+
+    const obj: Record<string, RuleEffectiveness> = {}
+    for (const [k, v] of this.data) {
+      obj[k] = v
+    }
+    writeFileSync(this.storePath, JSON.stringify(obj, null, 2), 'utf-8')
+  }
+
+  load(): void {
+    if (!existsSync(this.storePath)) return
+    try {
+      const raw = JSON.parse(readFileSync(this.storePath, 'utf-8'))
+      this.data = new Map(Object.entries(raw))
+    } catch {
+      // Corrupt file — start fresh
+      this.data = new Map()
+    }
+  }
+
+  get allRules(): RuleEffectiveness[] {
+    return Array.from(this.data.values())
+  }
+}