@miphamai/cli 0.69.0 → 0.71.0

package/src/ui/commands.ts

@@ -14,6 +14,8 @@ import { McpClient } from '../mcp/client'
 import { buildCapabilityReport } from '../core/capability-inventory'
 import { InstructionsLoader } from '../core/instructions'
 import { findDerivableSections, DERIVABLE_HINTS } from '../core/claude-md-audit'
+import { fixDoctor, fixConfig, fixCache, selectRepoClaudeFiles } from '../core/fix'
+import { fixCodeTarget } from '../core/fix-code'
 import { runCrsiModification, approvePending, rejectPending, hasPending } from '../core/crsi-modify'
 import {
   produceCrsiProposal,
@@ -32,7 +34,11 @@ import {
 import { prefilterProposal } from '../core/proposal-guard'
 import { runEval, appendEvalScore } from '../core/eval-harness'
 import { listRewardFns } from '../core/reward-fn'
-import { runTaskPerformance, measureSkillDeltaRepeated } from '../core/task-performance'
+import {
+  runTaskPerformance,
+  measureSkillDeltaRepeated,
+  stripCodeFences,
+} from '../core/task-performance'
 import { randomUUID } from 'node:crypto'
 import {
   buildImprovementReport,
@@ -45,7 +51,7 @@ import {
 } from '../core/improvement-track'
 import { NPM_UPDATE_COMMAND, PACKAGE_VERSION, COAUTHOR_TRAILER } from '../shared/index.ts'
 import { getPreference } from '../config/preferences'
-import { loadCrossSessionConfig } from '../config/loader'
+import { loadCrossSessionConfig, tryRestoreFromBackup } from '../config/loader'
 import { getMemoryManager } from '../core/memory/memory-loader'
 import { stripIndent } from './strip-indent.js'
 import { createT } from '../i18n-core/t'
@@ -394,11 +400,20 @@ const statusCmd: CommandHandler = async (ctx) => {
 const costCmd: CommandHandler = (ctx) => {
   const t = resolveT(ctx)
   const tokens = ctx.engine.getContext().getEstimatedTokens()
+  const cacheStatus = ctx.engine.getContext().getCacheStatus()
+  const cachedTokens = cacheStatus.cachedTokens
+  const hitRatio = tokens > 0 ? Math.min(1, cachedTokens / tokens) : 0
+  const uncachedTokens = Math.max(0, tokens - cachedTokens)
   return {
     content: stripIndent`
       ${t('commands.context_tokens.title')}
       ${t('commands.context_tokens.context_tokens')} ~${tokens.toLocaleString()} / 200,000
       ${t('commands.context_tokens.usage')} ${((tokens / 200_000) * 100).toFixed(1)}%
+      ${t('commands.context_tokens.prompt_cache', {
+        cached: cachedTokens.toLocaleString(),
+        ratio: (hitRatio * 100).toFixed(1),
+        uncached: uncachedTokens.toLocaleString(),
+      })}
 
       ${t('commands.context_tokens.footer')}
     `,
@@ -2359,9 +2374,9 @@ const installSkillCmd: CommandHandler = async (ctx, args) => {
   let result: { success: boolean; name: string; message: string }
 
   if (target.startsWith('http://') || target.startsWith('https://')) {
-    result = installSkillFromUrl(target, marketplaceConfig)
+    result = await installSkillFromUrl(target, marketplaceConfig)
   } else {
-    result = installSkill(target, marketplaceConfig)
+    result = await installSkill(target, marketplaceConfig)
   }
 
   return {
@@ -2383,6 +2398,83 @@ const removeSkillCmd: CommandHandler = async (_ctx, args) => {
   }
 }
 
+const marketplaceCmd: CommandHandler = async (_ctx, args) => {
+  const {
+    readMarketplaces,
+    addMarketplace,
+    removeMarketplace,
+    isValidMarketplaceRef,
+    MARKETPLACES_PATH,
+  } = await import('../skills/marketplace')
+  const { readFileSync, writeFileSync, existsSync, mkdirSync } = await import('node:fs')
+  const { dirname } = await import('node:path')
+
+  const readSources = () =>
+    readMarketplaces((p) => (existsSync(p) ? readFileSync(p, 'utf-8') : null))
+
+  const sub = args[0]
+  const ref = args[1]
+
+  if (!sub || sub === 'list') {
+    const sources = readSources()
+    const lines = ['── Marketplace Sources ──', '']
+    for (const s of sources) lines.push(`  ${s.owner}/${s.repo}`)
+    lines.push(
+      '',
+      'Add:    /marketplace add <owner>/<repo>',
+      'Remove: /marketplace remove <owner>/<repo>',
+    )
+    return { content: lines.join('\n') }
+  }
+
+  if (sub === 'add' || sub === 'remove') {
+    if (!ref) return { content: `Usage: /marketplace ${sub} <owner>/<repo>` }
+    const [owner, repo] = ref.split('/')
+    if (!owner || !repo || !isValidMarketplaceRef(owner, repo)) {
+      return { content: `❌ Invalid marketplace ref "${ref}". Expected <owner>/<repo>.` }
+    }
+    const current = readSources()
+    const result =
+      sub === 'add' ? addMarketplace(current, owner, repo) : removeMarketplace(current, owner, repo)
+    const changed = 'added' in result ? result.added : result.removed
+    try {
+      mkdirSync(dirname(MARKETPLACES_PATH), { recursive: true })
+      writeFileSync(MARKETPLACES_PATH, JSON.stringify(result.sources, null, 2), 'utf-8')
+    } catch (err) {
+      return { content: `❌ Failed to save marketplaces: ${String(err)}` }
+    }
+    if (sub === 'add') {
+      return {
+        content: changed ? `✅ Added ${owner}/${repo}` : `ℹ ${owner}/${repo} already exists`,
+      }
+    }
+    return { content: changed ? `✅ Removed ${owner}/${repo}` : `ℹ ${owner}/${repo} not found` }
+  }
+
+  return { content: 'Usage: /marketplace add|list|remove [owner/repo]' }
+}
+
+const browseMarketplaceCmd: CommandHandler = async (_ctx) => {
+  const { readMarketplaces, discoverSkills, downloadFile } = await import('../skills/marketplace')
+  const { readFileSync, existsSync } = await import('node:fs')
+
+  const sources = readMarketplaces((p) => (existsSync(p) ? readFileSync(p, 'utf-8') : null))
+  const lines = ['── Marketplace Skills ──', '']
+  for (const source of sources) {
+    lines.push(`  ${source.owner}/${source.repo}:`)
+    try {
+      const skills = await discoverSkills(source, globalThis.fetch, downloadFile)
+      if (skills.length === 0) lines.push('    (no skills found)')
+      for (const s of skills) lines.push(`    ${s.name.padEnd(24)} ${s.description}`)
+    } catch {
+      lines.push('    (failed to discover — check network / rate limit)')
+    }
+    lines.push('')
+  }
+  lines.push('Install: /install-skill <name>')
+  return { content: lines.join('\n') }
+}
+
 // ═══════════════════════════════════════════════════════════════
 // Plugins — Community plugin marketplace + local management
 // ═══════════════════════════════════════════════════════════════
@@ -3105,6 +3197,191 @@ const doctorCmd: CommandHandler = async (ctx) => {
   return { content: lines.join('\n') }
 }
 
+const fixCmd: CommandHandler = async (ctx, args) => {
+  const t = resolveT(ctx)
+  const { readFileSync, writeFileSync } = await import('node:fs')
+  const { join } = await import('node:path')
+  const { homedir } = await import('node:os')
+  const { parse: parseYaml } = await import('yaml')
+
+  const target = args.find((a) => a === 'doctor' || a === 'config' || a === 'cache' || a === 'test')
+  const dryRun = args.includes('--dry-run')
+  const apply = args.includes('--apply')
+
+  const lines: string[] = [t('commands.fix.title')]
+  if (dryRun) lines.push(t('commands.fix.dryrun_banner'))
+  lines.push('')
+
+  const readSafe = (p: string): string | null => {
+    try {
+      return readFileSync(p, 'utf-8')
+    } catch {
+      return null
+    }
+  }
+
+  if (!target || target === 'doctor') {
+    const loader = new InstructionsLoader()
+    loader.loadAll(process.cwd())
+    const files = selectRepoClaudeFiles(loader.list())
+    const result = fixDoctor(files, {
+      read: readSafe,
+      write: (p, c) => {
+        if (!dryRun) writeFileSync(p, c, 'utf-8')
+      },
+    })
+    if (result.fixed.length === 0) {
+      lines.push(t('commands.fix.doctor_clean'))
+    } else {
+      for (const f of result.fixed) {
+        lines.push(t('commands.fix.doctor_fixed', { path: f.path, added: f.added.join(', ') }))
+      }
+    }
+    lines.push('')
+  }
+
+  if (!target || target === 'config') {
+    const home = homedir()
+    const configPaths = [
+      join(process.cwd(), '.mipham', 'config.yml'),
+      join(home, '.mipham', 'config.yml'),
+    ]
+    const hookEngine = ctx.engine.getHookEngine?.()
+    const result = fixConfig({
+      configPaths,
+      read: readSafe,
+      parseYaml,
+      restore: (p) => tryRestoreFromBackup(p),
+      hookHealth: () =>
+        hookEngine
+          ? hookEngine.getHookHealth().map((h) => ({ key: h.key, disabled: h.health.disabled }))
+          : [],
+      reEnableHook: (k) => (hookEngine ? hookEngine.reEnableHook(k) : false),
+      dryRun,
+    })
+    if (result.corruptConfigs.length === 0 && result.disabledHooks.length === 0) {
+      lines.push(t('commands.fix.config_clean'))
+    } else {
+      for (const p of result.restoredConfigs) {
+        lines.push(t('commands.fix.config_restored', { path: p }))
+      }
+      for (const p of result.corruptConfigs.filter((p) => !result.restoredConfigs.includes(p))) {
+        lines.push(t('commands.fix.config_corrupt', { path: p }))
+      }
+      for (const k of result.reenabledHooks) {
+        lines.push(t('commands.fix.hook_reenabled', { key: k }))
+      }
+      for (const k of result.disabledHooks.filter((k) => !result.reenabledHooks.includes(k))) {
+        lines.push(t('commands.fix.hook_disabled', { key: k }))
+      }
+    }
+    lines.push('')
+  }
+
+  if (!target || target === 'cache') {
+    const crsiDir = join(homedir(), '.mipham', 'crsi')
+    const cacheFiles = ['eval-scores.jsonl', 'improvements.jsonl', 'prose-proposals.jsonl'].map(
+      (f) => join(crsiDir, f),
+    )
+    const result = fixCache(
+      cacheFiles,
+      {
+        read: readSafe,
+        write: (p, c) => writeFileSync(p, c, 'utf-8'),
+      },
+      apply && !dryRun,
+    )
+    if (result.files.length === 0) {
+      lines.push(t('commands.fix.cache_clean'))
+    } else {
+      for (const f of result.files) {
+        lines.push(
+          t('commands.fix.cache_found', { path: f.path, count: String(f.corruptLines.length) }),
+        )
+      }
+      if (apply && !dryRun) {
+        for (const c of result.cleaned) {
+          lines.push(t('commands.fix.cache_cleaned', { path: c.path, count: String(c.removed) }))
+        }
+      } else {
+        lines.push(t('commands.fix.cache_hint'))
+      }
+    }
+    lines.push('')
+  }
+
+  if (!target || target === 'test') {
+    const testFile = args.find(
+      (a) =>
+        !a.startsWith('--') && a !== 'test' && a !== 'doctor' && a !== 'config' && a !== 'cache',
+    )
+    if (!testFile) {
+      lines.push(t('commands.fix.test_usage'))
+    } else {
+      const llm = ctx.engine.getLlm() ?? ctx.engine.getRegistry()
+      if (!llm) {
+        lines.push(t('commands.fix.test_no_llm'))
+      } else {
+        const { execSync } = await import('node:child_process')
+        const { dirname, resolve } = await import('node:path')
+        const result = await fixCodeTarget(
+          {
+            runVitest: (file) => {
+              try {
+                const output = execSync(`pnpm vitest run '${file}'`, {
+                  cwd: process.cwd(),
+                  encoding: 'utf-8',
+                  stdio: ['ignore', 'pipe', 'pipe'],
+                })
+                return { exitCode: 0, output }
+              } catch (e) {
+                const err = e as { stdout?: string; stderr?: string }
+                return { exitCode: 1, output: `${err.stdout ?? ''}${err.stderr ?? ''}` }
+              }
+            },
+            readFile: readSafe,
+            writeFile: (p, c) => writeFileSync(p, c, 'utf-8'),
+            generateFix: async (prompt) => {
+              let text = ''
+              for await (const chunk of llm.chat({
+                model: '',
+                messages: [{ role: 'user' as const, content: prompt }],
+                temperature: 0,
+              })) {
+                if (chunk.type === 'text' && chunk.content) text += chunk.content
+              }
+              return stripCodeFences(text)
+            },
+            resolveSourceFile: (tf, specifier) => {
+              const base = resolve(dirname(tf), specifier)
+              return /\.[cm]?[jt]sx?$/.test(base) ? base : `${base}.ts`
+            },
+          },
+          testFile,
+          { apply: apply && !dryRun, maxRetries: 3 },
+        )
+        if (result.fixed) {
+          lines.push(
+            t('commands.fix.test_fixed', {
+              test: result.testFile,
+              source: result.sourceFile ?? '-',
+              attempts: String(result.attempts),
+            }),
+          )
+          if (!apply) lines.push(t('commands.fix.test_hint'))
+        } else {
+          lines.push(
+            t('commands.fix.test_failed', { test: result.testFile, detail: result.detail ?? '' }),
+          )
+        }
+      }
+    }
+    lines.push('')
+  }
+
+  return { content: lines.join('\n').trimEnd() }
+}
+
 // ═══════════════════════════════════════════════════════════════
 // GitHub & Git Workflow Commands (Claude Code parity)
 // ═══════════════════════════════════════════════════════════════
@@ -3422,42 +3699,44 @@ const cdCmd: CommandHandler = async (ctx, args) => {
 
 const hooksCmd: CommandHandler = async (ctx) => {
   const t = resolveT(ctx)
-  const { existsSync, readdirSync } = await import('node:fs')
-  const { join } = await import('node:path')
-  const cwd = process.cwd()
-  const hooksDir = join(cwd, '.mipham', 'hooks')
+  const { loadSettingsJson } = await import('../config/loader')
+  const settingsJson = loadSettingsJson(process.cwd())
+
+  const hooks = settingsJson.hooks as Record<
+    string,
+    Array<{ matcher?: string; hooks: Array<{ type: string; command?: string }> }>
+  >
+
+  const configured = Object.entries(hooks).filter(
+    ([, entries]) => Array.isArray(entries) && entries.length > 0,
+  )
 
-  if (!existsSync(hooksDir)) {
+  if (configured.length === 0) {
     return { content: t('commands.hooks.no_hooks') }
   }
 
-  try {
-    const files = readdirSync(hooksDir).filter((f) => f.endsWith('.sh'))
-    const lines: string[] = [
-      t('commands.hooks.title'),
-      '',
-      t('commands.hooks.location', { path: hooksDir }),
-      '',
-    ]
+  const lines: string[] = [
+    t('commands.hooks.title'),
+    '',
+    t('commands.hooks.location', { path: '.mipham/settings.json' }),
+    '',
+  ]
 
-    for (const f of files) {
-      try {
-        const stat = (await import('node:fs')).statSync(join(hooksDir, f))
-        const isExec = (stat.mode & 0o111) !== 0
-        lines.push(
-          `  ${isExec ? '✅' : '⚠️'} ${f}${isExec ? '' : ' (not executable — run chmod +x)'}`,
-        )
-      } catch {
-        lines.push(`  📄 ${f}`)
+  let count = 0
+  for (const [eventName, entries] of configured) {
+    for (const entry of entries) {
+      for (const hook of entry.hooks) {
+        count++
+        const matcher = entry.matcher || '*'
+        const cmd = hook.type === 'command' && hook.command ? hook.command : hook.type
+        lines.push(`  ${eventName} [${matcher}] → ${cmd}`)
       }
     }
-
-    lines.push('')
-    lines.push(t('commands.hooks.found', { count: String(files.length) }))
-    return { content: lines.join('\n') }
-  } catch {
-    return { content: t('commands.hooks.error') }
   }
+
+  lines.push('')
+  lines.push(t('commands.hooks.found', { count: String(count) }))
+  return { content: lines.join('\n') }
 }
 
 const hooksHealthCmd: CommandHandler = (ctx) => {
@@ -3816,6 +4095,23 @@ const memoryCmd: CommandHandler = async (ctx, args) => {
     return { content: lines.join('\n') }
   }
 
+  // /memory dedup — 只读近重复报告：列出 TF-IDF 余弦 > 阈值的近重复对，用户决定是否合并
+  if (args[0]?.toLowerCase() === 'dedup') {
+    const mm = getMemoryManager()
+    const pairs = mm.listNearDuplicates()
+    const lines: string[] = [t('commands.memories.dedup_title'), '']
+    if (pairs.length === 0) {
+      lines.push(t('commands.memories.dedup_none'))
+    } else {
+      for (const { a, b, similarity } of pairs) {
+        lines.push(`  ${a} ↔ ${b}  (${(similarity * 100).toFixed(0)}%)`)
+      }
+      lines.push('')
+      lines.push(t('commands.memories.dedup_footer'))
+    }
+    return { content: lines.join('\n') }
+  }
+
   if (!existsSync(memoryDir)) {
     return { content: t('commands.memories.no_memories') }
   }
@@ -4225,6 +4521,14 @@ const mcpCmd: CommandHandler = async (ctx, args) => {
       }
     }
     const via = config.url ? 'HTTP' : 'stdio'
+    if (config.url) {
+      const headerKeys = config.headers ? Object.keys(config.headers) : []
+      const headerLine = headerKeys.length > 0 ? `\nHeaders to send: ${headerKeys.join(', ')}` : ''
+      return {
+        content: `── MCP Connect: ${name} ──\n\nConnecting via HTTP\nURL: ${config.url}${headerLine}\n\n⚠️ Verify the URL — any configured headers (e.g. Authorization) will be sent to this server.`,
+        forwardToAI: `Connect to MCP server "${name}" using McpClient.getInstance().connect(config), then register its tools. Report the result.`,
+      }
+    }
     return {
       content: `── MCP Connect: ${name} ──\n\nConnecting via ${via}...`,
       forwardToAI: `Connect to MCP server "${name}" using McpClient.getInstance().connect(config), then register its tools. Report the result.`,
@@ -4868,6 +5172,8 @@ const commandsListCmd: CommandHandler = () => {
     '/reload-skills': 'Tools & Skills',
     '/browse-skills': 'Tools & Skills',
     '/install-skill': 'Tools & Skills',
+    '/marketplace': 'Tools & Skills',
+    '/browse-marketplace': 'Tools & Skills',
     '/remove-skill': 'Tools & Skills',
     '/mcp': 'Tools & Skills',
     '/plugins': 'Plugins',
@@ -5028,6 +5334,8 @@ registry.set('/skills', skillsCmd)
 registry.set('/reload-skills', reloadSkillsCmd)
 registry.set('/browse-skills', browseSkillsCmd)
 registry.set('/install-skill', installSkillCmd)
+registry.set('/marketplace', marketplaceCmd)
+registry.set('/browse-marketplace', browseMarketplaceCmd)
 registry.set('/remove-skill', removeSkillCmd)
 registry.set('/plugins', pluginsCmd)
 registry.set('/browse-plugins', browsePluginsCmd)
@@ -5079,6 +5387,7 @@ registry.set('/pr-comments', prCommentsCmd)
 
 // Session Management
 registry.set('/doctor', doctorCmd)
+registry.set('/fix', fixCmd)
 registry.set('/export', exportCmd)
 registry.set('/resume', resumeCmd)
 registry.set('/resume last', resumeLastCmd)
@@ -5183,6 +5492,7 @@ const COMMAND_DESCRIPTIONS: Record<string, string> = {
   '/save': 'Save conversation to Obsidian wiki (skill: save-to-wiki)',
   '/export': 'Export conversation to file',
   '/doctor': 'System diagnostics',
+  '/fix': 'Deterministic self-repair: doctor/config/cache',
   '/dream': 'Background memory consolidation',
   '/constitution': 'View or reload constitutional principles',
   '/bug-report': 'Generate diagnostic report for GitHub Issues',
@@ -5212,6 +5522,8 @@ const COMMAND_DESCRIPTIONS: Record<string, string> = {
   '/reload-skills': 'Reload all skills',
   '/browse-skills': 'Browse community skill marketplace',
   '/install-skill': 'Install a skill by name or URL',
+  '/marketplace': 'Manage marketplace sources (add/list/remove)',
+  '/browse-marketplace': 'Browse skills across all marketplace sources',
   '/remove-skill': 'Remove an installed skill',
   '/mcp': 'MCP server status',
   '/plugins': 'List installed plugins',
@@ -5294,7 +5606,7 @@ const COMMAND_DESCRIPTIONS: Record<string, string> = {
   '/stats': 'Show session usage statistics',
   '/summary': 'Generate session summary',
   '/cd': 'Change session working directory',
-  '/hooks': 'Manage lifecycle hook scripts',
+  '/hooks': 'List configured hooks from settings.json',
   '/hooks health': 'Check hook health — see failures, disabled hooks, recovery status',
   '/hooks enable': 'Manually re-enable a hook that was auto-disabled after repeated failures',
   '/batch': 'Apply changes across multiple files',