@miphamai/cli 0.15.0 → 0.16.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.15.0",
+  "version": "0.16.1",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",
@@ -42,13 +42,11 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "commander": "^13.1.0",
     "ink": "^5.2.1",
     "ink-text-input": "^6.0.0",
     "react": "^18.3.1",
     "react-devtools-core": "^4.28.5",
-    "yaml": "^2.9.0",
-    "zod": "^3.25.76"
+    "yaml": "^2.9.0"
   },
   "devDependencies": {
     "@mipham/shared": "workspace:*",

package/src/agent/message-bus.ts

@@ -11,6 +11,8 @@
  *   const unread = bus.poll('bg-1')  // messages addressed TO bg-1
  */
 
+export type AgentMessageType = 'message' | 'warning' | 'error'
+
 export interface AgentMessage {
   id: string
   from: string
@@ -19,6 +21,7 @@ export interface AgentMessage {
   message: string
   timestamp: Date
   read: boolean
+  type: AgentMessageType
 }
 
 export class AgentMessageBus {
@@ -29,7 +32,13 @@ export class AgentMessageBus {
    * Post a message from one agent to another.
    * Returns the message ID.
    */
-  post(from: string, to: string, summary: string, message: string): string {
+  post(
+    from: string,
+    to: string,
+    summary: string,
+    message: string,
+    type: AgentMessageType = 'message',
+  ): string {
     const id = `msg-${++this.idCounter}`
     this.messages.push({
       id,
@@ -39,6 +48,7 @@ export class AgentMessageBus {
       message,
       timestamp: new Date(),
       read: false,
+      type,
     })
     return id
   }
@@ -91,6 +101,14 @@ export class AgentMessageBus {
     return this.messages.filter((m) => m.to === agentId && !m.read).length
   }
 
+  /**
+   * Get all unread warning messages for an agent.
+   * Does NOT mark them as read — use markRead() for that.
+   */
+  getWarnings(agentId: string): AgentMessage[] {
+    return this.messages.filter((m) => m.to === agentId && m.type === 'warning' && !m.read)
+  }
+
   /**
    * Prune messages older than maxAgeMs. Returns the number pruned.
    */

package/src/agent/sub-agent.ts

@@ -3,6 +3,7 @@ import type { ToolDefinition } from '../shared/index.ts'
 import type { SubAgentType, SubAgentOptions, AgentDefinition } from './types'
 import { createAgentContext } from './agent-context'
 import { getBackgroundAgentRegistry } from './background-registry'
+import { getMessageBus } from './message-bus'
 import type { HookEngine } from '../core/hooks'
 import type { PermissionSystem } from '../core/permission'
 
@@ -156,6 +157,28 @@ export class SubAgent {
     // 'inherit' means use parent model
     const resolvedModel = modelToUse === 'inherit' ? model : modelToUse
 
+    // Validate resolved model exists in registry; fall back to parent model with warning
+    let finalModel = resolvedModel
+    if (resolvedModel !== model) {
+      const modelExists = this.registry.findModel(resolvedModel) !== undefined
+      if (!modelExists) {
+        const warnMsg = `Warning: model "${resolvedModel}" not found in provider registry. Falling back to "${model}".`
+        console.warn(warnMsg)
+
+        // Post warning to message bus for UI display
+        const bus = getMessageBus()
+        bus.post(
+          'system',
+          'main',
+          `Sub-agent model fallback: ${resolvedModel} → ${model}`,
+          warnMsg,
+          'warning',
+        )
+
+        finalModel = model
+      }
+    }
+
     const chunks: string[] = []
     const MAX_TOOL_TURNS = options.maxTurns || 5
 
@@ -173,7 +196,7 @@ export class SubAgent {
         let turnText = ''
 
         for await (const chunk of provider.chat({
-          model: resolvedModel,
+          model: finalModel,
           messages: currentMessages,
           systemPrompt: currentSystemPrompt,
           tools: toolDefs,
@@ -251,7 +274,7 @@ export class SubAgent {
               cwd: execCwd,
               sessionId: 'sub-agent',
               provider: '',
-              model: resolvedModel,
+              model: finalModel,
             })
 
             currentMessages.push({

package/src/commands/environment.ts

@@ -0,0 +1,270 @@
+/**
+ * Mipham Code — Environment Slash Commands
+ *
+ * Extracted from ui/commands.ts (2026-08-06).
+ * Handlers for: /theme, /release-notes, /ide, /terminal-setup
+ */
+import type { CommandHandler } from '../ui/commands.js'
+import { stripIndent } from '../ui/strip-indent.js'
+import { NPM_INSTALL_COMMAND, NPM_UPDATE_COMMAND, PACKAGE_VERSION } from '../shared/index.ts'
+
+export { themeCmd, releaseNotesCmd, ideCmd, terminalSetupCmd }
+
+const themeCmd: CommandHandler = (_ctx, args) => {
+  const theme = args[0]?.toLowerCase()
+  const validThemes = ['dark', 'light', 'auto'] as const
+
+  if (!theme || !validThemes.includes(theme as (typeof validThemes)[number])) {
+    return {
+      content: `── Theme ──
+
+Terminal color themes (set in .mipham/config.yml):
+
+  theme: dark    — dark background (default, recommended for terminals)
+  theme: light   — light background
+  theme: auto    — follow system preference
+
+Usage: /theme dark | light | auto
+
+Current: auto (follows terminal)`,
+    }
+  }
+
+  return {
+    content: `✓ Theme set to "${theme}".
+
+Add to ~/.mipham/config.yml to persist:
+  theme: ${theme}
+
+Terminal themes affect syntax highlighting and UI accents.
+Full theme customization is available in the Web UI at https://mipham.ai/code/dashboard`,
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Add-Dir — add a directory to workspace permissions
+// ═══════════════════════════════════════════════════════════════
+
+// ═══════════════════════════════════════════════════════════════
+// Security / Audit — security review checklist
+// ═══════════════════════════════════════════════════════════════
+
+// ═══════════════════════════════════════════════════════════════
+// Release Notes — version changelog
+// ═══════════════════════════════════════════════════════════════
+
+const releaseNotesCmd: CommandHandler = () => ({
+  content: `── Release Notes ──
+
+v0.1.2 (2026-06-09) — Current
+  • 48 slash commands (up from 20)
+  • /setup guided project initialization wizard
+  • Checkpoint/rewind mechanism
+  • Focus mode (last exchange view)
+  • 3-level MIPHAM.md architecture
+  • /doctor system diagnostics
+  • /export conversation to file
+  • /review and /pr-comments code review workflows
+  • /memory management
+  • /upgrade instructions
+  • Clipboard support (macOS/Windows)
+
+v0.1.1 (2026-06-02)
+  • Inline shared module for standalone builds
+  • Bin path fix for npm compatibility
+
+v0.1.0 (2026-06-01)
+  • Initial release
+  • Multi-model support (7 providers)
+  • 16 built-in tools
+  • 11 skills (9 standard + 2 mipham)
+  • Ctrl+P interactive model picker
+  • SSE streaming support
+
+Full changelog: https://mipham.ai/code/releases`,
+})
+
+// ═══════════════════════════════════════════════════════════════
+// IDE — IDE integration guide
+// ═══════════════════════════════════════════════════════════════
+
+const ideCmd: CommandHandler = async (_ctx) => {
+  const { mkdirSync, writeFileSync, existsSync } = await import('node:fs')
+  const { join } = await import('node:path')
+
+  const cwd = process.cwd()
+  const vscodeDir = join(cwd, '.vscode')
+  mkdirSync(vscodeDir, { recursive: true })
+
+  const files: string[] = []
+
+  // ── Detect bun path ──
+  let bunPath = '/opt/homebrew/bin/bun'
+  try {
+    const { execSync } = await import('node:child_process')
+    const detected = execSync('which bun 2>/dev/null || echo /opt/homebrew/bin/bun', {
+      encoding: 'utf-8',
+    }).trim()
+    if (detected) bunPath = detected
+  } catch {
+    // Use default
+  }
+
+  // ── settings.json: terminal profile ──
+  const settingsPath = join(vscodeDir, 'settings.json')
+  const settings = {
+    'terminal.integrated.profiles.osx': {
+      mipham: {
+        path: bunPath,
+        args: ['run', 'mipham'],
+        cwd: '${workspaceFolder}',
+      },
+    },
+  }
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8')
+  files.push('.vscode/settings.json')
+
+  // ── keybindings.json: Cmd+Esc launch ──
+  const keybindingsPath = join(vscodeDir, 'keybindings.json')
+  const keybindings = [
+    {
+      key: 'cmd+escape',
+      command: 'workbench.action.terminal.focus',
+      when: 'terminalProcessSupported',
+    },
+    {
+      key: 'cmd+shift+m',
+      command: 'workbench.action.terminal.new',
+    },
+  ]
+  writeFileSync(keybindingsPath, JSON.stringify(keybindings, null, 2) + '\n', 'utf-8')
+  files.push('.vscode/keybindings.json')
+
+  // ── extensions.json: recommended ──
+  const extensionsPath = join(vscodeDir, 'extensions.json')
+  const extensions = {
+    recommendations: ['miphamai.mipham-code'],
+  }
+  writeFileSync(extensionsPath, JSON.stringify(extensions, null, 2) + '\n', 'utf-8')
+  files.push('.vscode/extensions.json')
+
+  return {
+    content: [
+      '── VS Code Integration ──',
+      '',
+      `Generated in ${vscodeDir}:`,
+      ...files.map((f) => `  ✅ ${f}`),
+      '',
+      'What was configured:',
+      '  • Terminal profile "mipham" — opens Mipham Code in integrated terminal',
+      '  • Keyboard shortcut Cmd+Esc — focus terminal',
+      '  • Cmd+Shift+M — new terminal',
+      '',
+      'To use:',
+      '  1. Restart VS Code (or reload window: Cmd+Shift+P → Reload Window)',
+      '  2. Open terminal: Ctrl+` or Cmd+Esc',
+      '  3. Select "mipham" profile from the terminal dropdown',
+      '',
+      'Install the VS Code extension for full integration:',
+      `  code --install-extension miphamai.mipham-code`,
+      '',
+      'JetBrains: Settings → Tools → Terminal → Shell path → bun run mipham',
+    ].join('\n'),
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Terminal Setup — shell integration guide
+// ═══════════════════════════════════════════════════════════════
+
+const terminalSetupCmd: CommandHandler = async () => {
+  const { writeFileSync, appendFileSync, existsSync, mkdirSync, readFileSync } =
+    await import('node:fs')
+  const { join } = await import('node:path')
+  const { homedir } = await import('node:os')
+
+  const home = homedir()
+  const lines: string[] = ['── Terminal Setup ──', '']
+
+  // ── 1. Generate standalone shell setup script ──
+  const miphamDir = join(home, '.mipham')
+  mkdirSync(miphamDir, { recursive: true })
+
+  const shellScript = join(miphamDir, 'shell-setup.sh')
+  const shellContent = [
+    '#!/bin/bash',
+    '# Mipham Code — Shell Integration',
+    '# Source this file in your shell profile:',
+    '#   source ~/.mipham/shell-setup.sh',
+    '',
+    `export MIPHAM_HOME="${home}/.mipham"`,
+    '',
+    '# Alias: launch Mipham Code in current directory',
+    `alias mipham='cd $(pwd) && ${NPM_INSTALL_COMMAND} > /dev/null 2>&1; mipham'`,
+    '',
+    '# Or use the local development version:',
+    '# alias mipham="bun run /path/to/mipham-code/apps/cli/bin/mipham"',
+    '',
+    '# Auto-detect provider from config',
+    'if [ -f ~/.mipham/config.yml ]; then',
+    '  export MIPHAM_PROVIDER=$(grep "defaultProvider:" ~/.mipham/config.yml | awk "{print \$2}")',
+    'fi',
+  ].join('\n')
+  writeFileSync(shellScript, shellContent + '\n', 'utf-8')
+  lines.push(`  ✅ Generated: ${shellScript}`)
+
+  // ── 2. Append to shell profile ──
+  const shell = process.env.SHELL || '/bin/zsh'
+  const profileName = shell.includes('zsh') ? '.zshrc' : '.bashrc'
+  const profilePath = join(home, profileName)
+  const sourceLine = `\n# Mipham Code shell integration\n[ -f ~/.mipham/shell-setup.sh ] && source ~/.mipham/shell-setup.sh\n`
+
+  try {
+    const existing = existsSync(profilePath) ? readFileSync(profilePath, 'utf-8') : ''
+    if (existing.includes('shell-setup.sh')) {
+      lines.push(`  ⏭  ${profileName} already has Mipham Code integration`)
+    } else {
+      appendFileSync(profilePath, sourceLine, 'utf-8')
+      lines.push(`  ✅ Added to ~/${profileName}`)
+    }
+  } catch {
+    lines.push(`  ⚠️  Could not update ~/${profileName}. Add manually:`)
+    lines.push(`     echo '${sourceLine.trim()}' >> ~/${profileName}`)
+  }
+
+  // ── 3. Global install check ──
+  lines.push('')
+  lines.push('── Installation ──')
+  try {
+    const { execSync } = await import('node:child_process')
+    const miphamPath = execSync('which mipham 2>/dev/null || echo ""', { encoding: 'utf-8' }).trim()
+    if (miphamPath) {
+      lines.push(`  ✅ mipham found at: ${miphamPath}`)
+      const version = execSync('mipham --version 2>/dev/null || echo "unknown"', {
+        encoding: 'utf-8',
+      }).trim()
+      lines.push(`  📦 Version: ${version}`)
+    } else {
+      lines.push(`  ⚠️  mipham not in PATH. Install globally:`)
+      lines.push(`     ${NPM_INSTALL_COMMAND}`)
+      lines.push(`     or: curl -fsSL https://mipham.ai/install.sh | bash`)
+    }
+  } catch {
+    lines.push(`  💡 Install: ${NPM_INSTALL_COMMAND}`)
+  }
+
+  // ── 4. Verify ──
+  lines.push('')
+  lines.push('── Next Steps ──')
+  lines.push('  1. Restart your terminal or run: source ~/.mipham/shell-setup.sh')
+  lines.push('  2. Run: mipham --version')
+  lines.push('  3. Start coding: cd your-project && mipham')
+  lines.push('')
+  lines.push(`Works with: Zsh, Bash. Shell: ${shell}`)
+
+  return { content: lines.join('\n') }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Phase 4 — MCP Server Management
+// ═══════════════════════════════════════════════════════════════

package/src/commands/git.ts

@@ -0,0 +1,152 @@
+/**
+ * Mipham Code — Git & GitHub Slash Commands
+ *
+ * Extracted from ui/commands.ts (2026-08-06).
+ * Handlers for: /commit, /push, /pr, /issue
+ */
+import type { CommandHandler } from '../ui/commands.js'
+import { stripIndent } from '../ui/strip-indent.js'
+
+export { commitCmd, pushCmd, prCmd, issueCmd }
+
+/** Run a git command asynchronously — avoids blocking the TUI event loop. */
+async function git(args: string[], timeoutMs = 5000): Promise<string> {
+  const proc = Bun.spawn(['git', ...args], {
+    stdout: 'pipe',
+    stderr: 'pipe',
+  })
+  const exitCode = await Promise.race([
+    proc.exited,
+    new Promise<number>((resolve) => setTimeout(() => resolve(143), timeoutMs)),
+  ])
+  if (exitCode === 143) {
+    proc.kill()
+    return ''
+  }
+  const stdout = await new Response(proc.stdout).text()
+  return exitCode === 0 ? stdout.trim() : ''
+}
+
+const commitCmd: CommandHandler = async () => {
+  try {
+    const diff = await git(['diff', '--cached', '--stat'])
+    const unstaged = await git(['diff', '--name-only'])
+
+    if (!diff) {
+      let msg = '── Git Commit ──\n\nNo staged changes found.\n\n'
+      if (unstaged) {
+        msg +=
+          'Unstaged changes exist:\n' +
+          unstaged
+            .split('\n')
+            .map((f) => '  • ' + f)
+            .join('\n') +
+          '\n\n'
+      }
+      msg +=
+        'Run: git add <files> to stage changes first.\nOr type: "commit these changes" for AI assistance.'
+      return { content: msg }
+    }
+
+    return {
+      content: [
+        '── Git Commit ──',
+        '',
+        'Staged changes:',
+        diff,
+        '',
+        'To generate a commit message, type: "write a commit message for these changes"',
+        'To commit: git commit -m "your message"',
+        '',
+        'Tip: Use Conventional Commits format (feat:, fix:, chore:, docs:)',
+      ].join('\n'),
+    }
+  } catch {
+    return { content: '── Git Commit ──\n\nCould not run git. Are you in a git repository?' }
+  }
+}
+
+const pushCmd: CommandHandler = async () => {
+  try {
+    const branch = await git(['branch', '--show-current'], 3000)
+    const aheadRaw = await git(['rev-list', '--count', `origin/${branch}..HEAD`], 3000)
+    const ahead = aheadRaw || '0'
+
+    return {
+      content: [
+        '── Git Push ──',
+        '',
+        `Branch: ${branch || '(unknown)'}`,
+        `Commits ahead of remote: ${ahead}`,
+        '',
+        ahead !== '0'
+          ? `Ready to push ${ahead} commit(s). Run: git push origin ${branch}`
+          : 'Nothing to push (up to date).',
+        '',
+        'Or type: "push my changes" for AI assistance.',
+      ].join('\n'),
+    }
+  } catch {
+    return { content: '── Git Push ──\n\nCould not determine git status.' }
+  }
+}
+
+const prCmd: CommandHandler = async () => {
+  try {
+    const branch = await git(['branch', '--show-current'], 3000)
+    const mainBranchRaw = await git(['remote', 'show', 'origin'], 3000)
+    const mainBranch = mainBranchRaw.match(/HEAD branch:\s*(\S+)/)?.[1] || 'main'
+
+    const diff =
+      (await git(['diff', '--stat', `origin/${mainBranch}...HEAD`], 5000)) ||
+      (await git(['diff', '--stat', `${mainBranch}...HEAD`], 5000))
+
+    const commits =
+      (await git(['log', '--oneline', `origin/${mainBranch}..HEAD`], 5000)) ||
+      (await git(['log', '--oneline', `${mainBranch}..HEAD`], 5000))
+
+    return {
+      content: [
+        '── Create Pull Request ──',
+        '',
+        `Branch: ${branch} → ${mainBranch}`,
+        '',
+        commits
+          ? `Commits:\n${commits
+              .split('\n')
+              .map((c) => '  ' + c)
+              .join('\n')}`
+          : 'No commits ahead.',
+        '',
+        diff ? `Changes:\n${diff}` : '',
+        '',
+        'To create PR: type "create a pull request" for AI assistance.',
+        'Or use: gh pr create --base ' + mainBranch + ' --head ' + branch,
+      ].join('\n'),
+    }
+  } catch {
+    return { content: '── Create Pull Request ──\n\nCould not determine PR context.' }
+  }
+}
+
+const issueCmd: CommandHandler = async () => {
+  return {
+    content: [
+      '── GitHub Issues ──',
+      '',
+      'To file an issue, type: "create a GitHub issue for [description]"',
+      '',
+      'Quick commands:',
+      '  gh issue create --title "..." --body "..."',
+      '  gh issue list',
+      '',
+      'Use /github-ops skill for advanced GitHub automation.',
+    ].join('\n'),
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Code Quality — bridge slash commands to skills (Claude Code parity)
+// ═══════════════════════════════════════════════════════════════
+
+/** Factory for git-diff-based commands that bridge to AI skills via forwardToAI. */