@miphamai/cli 0.10.0 → 0.12.0

package/src/shared/types.ts

@@ -196,6 +196,7 @@ export type HookEvent =
   | 'ConfigChange'
   | 'SubagentStart'
   | 'SubagentStop'
+  | 'PreInference'
 
 export type HookType = 'command' | 'http' | 'code' | 'mcp_tool'
 
@@ -226,6 +227,18 @@ export interface HookContext {
   userPrompt?: string
   configKey?: string
   configValue?: unknown
+  /** PreInference: full conversation messages for DLP inspection. */
+  messages?: Array<{ role: string; content: string }>
+  /** PreInference: recent tool calls and their results. */
+  toolCalls?: Array<{
+    name: string
+    input: Record<string, unknown>
+    resultPreview: string
+  }>
+  /** PreInference: current provider ID. */
+  provider?: string
+  /** PreInference: current model ID. */
+  model?: string
 }
 
 export interface HookResult {
@@ -278,3 +291,47 @@ export interface PermissionRule {
   level: PermissionLevel
   pattern?: string
 }
+
+// ── Inference Hook (DLP) Types ──
+
+/** Configuration for the PreInference DLP hook, loaded from config.yml. */
+export interface InferenceHookConfig {
+  /** DLP server endpoint (HTTPS). Empty = feature disabled. */
+  endpoint: string
+  /** HMAC signing secret (format: mis_<random>). */
+  signing_secret: string
+  /** Request timeout in milliseconds. Default 5000. */
+  timeout: number
+  /** Failure posture: 'fail-closed' blocks on error, 'fail-open' allows. */
+  on_failure: 'fail-closed' | 'fail-open'
+  /** Organization identifier (optional, sent in payload). */
+  organization_id: string
+  /** Additional custom headers to send with each request. */
+  headers: Record<string, string>
+}
+
+/** Outgoing request to the DLP server. */
+export interface InferenceCheckRequest {
+  type: 'inference_check'
+  id: string
+  created_at: string
+  data: {
+    type: 'pre_inference'
+    session_id: string
+    organization_id?: string
+    provider: string
+    model: string
+    messages: Array<{ role: string; content: string }>
+    tool_calls: Array<{
+      name: string
+      input: Record<string, unknown>
+      result_preview: string
+    }>
+  }
+}
+
+/** Response from the DLP server. */
+export interface InferenceCheckResponse {
+  verdict: 'allow' | 'deny'
+  reason?: string
+}

package/src/tools/index.ts

@@ -20,6 +20,7 @@ import { webFetchTool } from './network/web-fetch'
 import { webSearchTool } from './network/web-search'
 import { configTool } from './system/config'
 import { mcpTool } from './system/mcp'
+import { toolSearchTool } from './system/tool-search'
 import { artifactTool } from './artifact/artifact'
 import { reportFindingsTool } from './agent/report-findings'
 import { sendMessageTool } from './agent/send-message'
@@ -134,6 +135,7 @@ export function createToolRegistry(): Map<string, ToolDefinition> {
     // System tools
     withValidation(configTool),
     withValidation(mcpTool),
+    withValidation(toolSearchTool),
     // Artifact tools
     withValidation(artifactTool),
     // Computer Use tools

package/src/tools/system/tool-search.ts

@@ -0,0 +1,143 @@
+/**
+ * ToolSearch — search MCP server tools by name or description.
+ *
+ * Instead of loading all MCP tool definitions into the context upfront,
+ * the AI can call ToolSearch to discover relevant tools on demand.
+ * This saves ~85% of context tokens for large MCP servers (50-100 tools).
+ */
+
+import type { ToolDefinition } from '../../shared/index.ts'
+import { McpClient } from '../../mcp/client'
+
+export const toolSearchTool: ToolDefinition = {
+  name: 'ToolSearch',
+  description:
+    'Search available MCP server tools by name or description. ' +
+    'Use this to discover tools on demand instead of loading all tool definitions into context. ' +
+    'Returns matching tool names with their server and description.',
+  category: 'system',
+  permission: 'auto',
+  parameters: {
+    type: 'object',
+    properties: {
+      query: {
+        type: 'string',
+        description:
+          'Search query — matches against tool names and descriptions. Leave empty to list all available MCP tools.',
+      },
+      server: {
+        type: 'string',
+        description: 'Optional: limit search to a specific MCP server name.',
+      },
+      limit: {
+        type: 'integer',
+        description: 'Max results to return (default: 20).',
+      },
+    },
+    required: [],
+  },
+  async execute(params, _ctx) {
+    const query = ((params.query as string) || '').toLowerCase()
+    const serverFilter = (params.server as string) || ''
+    const limit = (params.limit as number) || 20
+
+    const client = McpClient.getInstance()
+    const connectedServers = client.getConnectedServers()
+
+    if (connectedServers.length === 0) {
+      return {
+        success: true,
+        content:
+          '── MCP Tool Search ──\n\n' +
+          'No MCP servers connected.\n\n' +
+          'Connect MCP servers in .mcp.json or via /mcp add <name> <url>.',
+      }
+    }
+
+    // Filter by server if specified
+    const servers = serverFilter
+      ? connectedServers.filter((s) => s.toLowerCase().includes(serverFilter))
+      : connectedServers
+
+    if (serverFilter && servers.length === 0) {
+      return {
+        success: true,
+        content:
+          `── MCP Tool Search ──\n\n` +
+          `No connected server matching "${serverFilter}".\n\n` +
+          `Connected servers: ${connectedServers.join(', ')}`,
+      }
+    }
+
+    // Collect matching tools
+    interface Match {
+      server: string
+      tool: string
+      description: string
+    }
+
+    const matches: Match[] = []
+
+    for (const serverName of servers) {
+      try {
+        const tools = client.getTools(serverName)
+        for (const tool of tools) {
+          const nameMatch = !query || tool.name.toLowerCase().includes(query)
+          const descMatch = !query || (tool.description || '').toLowerCase().includes(query)
+          if (nameMatch || descMatch) {
+            matches.push({
+              server: serverName,
+              tool: tool.name,
+              description: (tool.description || '').slice(0, 120),
+            })
+          }
+        }
+      } catch {
+        // Server disconnected mid-search — skip
+      }
+    }
+
+    if (matches.length === 0) {
+      return {
+        success: true,
+        content:
+          `── MCP Tool Search ──\n\n` +
+          `No tools matching "${query}" across ${servers.length} server(s).\n\n` +
+          `Try a different query, or omit the query to list all tools.`,
+      }
+    }
+
+    // Truncate to limit
+    const limited = matches.slice(0, limit)
+
+    const lines: string[] = [
+      `── MCP Tool Search ──`,
+      '',
+      `${limited.length} of ${matches.length} matching tool(s) across ${servers.length} server(s):`,
+      '',
+    ]
+
+    // Group by server
+    const byServer = new Map<string, Match[]>()
+    for (const m of limited) {
+      const list = byServer.get(m.server) || []
+      list.push(m)
+      byServer.set(m.server, list)
+    }
+
+    for (const [server, tools] of byServer) {
+      lines.push(`  ${server} (${tools.length}):`)
+      for (const t of tools) {
+        const desc = t.description ? ` — ${t.description}` : ''
+        lines.push(`    mcp__${server.replace(/[^a-z0-9-]/g, '_')}__${t.tool}${desc}`)
+      }
+      lines.push('')
+    }
+
+    if (matches.length > limit) {
+      lines.push(`... and ${matches.length - limit} more. Use "query" to narrow results.`)
+    }
+
+    return { success: true, content: lines.join('\n') }
+  },
+}

package/src/ui/commands.ts

@@ -3182,64 +3182,182 @@ Full changelog: https://mipham.ai/code/releases`,
 // IDE — IDE integration guide
 // ═══════════════════════════════════════════════════════════════
 
-const ideCmd: CommandHandler = () => ({
-  content: `── IDE Integration ──
-
-VS Code:
-  Install the Mipham Code extension from the VS Code marketplace.
-  • Open Command Palette (Cmd+Shift+P)
-  • Search "Mipham Code: Start"
-  • The terminal panel opens with Mipham Code loaded
+const ideCmd: CommandHandler = async (_ctx) => {
+  const { mkdirSync, writeFileSync, existsSync } = await import('node:fs')
+  const { join } = await import('node:path')
 
-  Or manually: add to .vscode/settings.json
-  {
-    "terminal.integrated.profiles.osx": {
-      "mipham": { "path": "bun", "args": ["run", "mipham"] }
-    }
-  }
+  const cwd = process.cwd()
+  const vscodeDir = join(cwd, '.vscode')
+  mkdirSync(vscodeDir, { recursive: true })
 
-JetBrains (IntelliJ / WebStorm / PyCharm):
-  • Settings → Tools → Terminal → Shell path
-  • Set to: bun run ~/path/to/mipham-code/apps/cli/bin/mipham
+  const files: string[] = []
 
-Terminal (any):
-  alias mipham='cd your-project && bun run path/to/mipham'
+  // ── 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')
 
-Or install globally: ${NPM_INSTALL_COMMAND}
+  // ── 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')
 
-Coming soon: dedicated VS Code & JetBrains plugin extensions.`,
-})
+  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 = () => ({
-  content: `── Terminal Setup ──
-
-Install globally:
-  ${NPM_INSTALL_COMMAND}
-  mipham
-
-One-liner install:
-  curl -fsSL https://mipham.ai/install.sh | bash
+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')
 
-Add to shell profile (~/.zshrc or ~/.bashrc):
-  alias mipham='bun run ~/path/to/mipham-code/apps/cli/bin/mipham'
+  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`
 
-  # Or with a specific provider/model:
-  alias mipham='mipham --provider anthropic --model claude-opus-4-8'
+  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}`)
+  }
 
-Upgrade:
-  curl -fsSL https://mipham.ai/install.sh | bash
-  # or:   ${NPM_UPDATE_COMMAND}
+  // ── 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}`)
+  }
 
-Verify installation:
-  mipham --version
-  mipham --help
+  // ── 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}`)
 
-Works with: Bash, Zsh, Fish, PowerShell, Windows Terminal`,
-})
+  return { content: lines.join('\n') }
+}
 
 // ═══════════════════════════════════════════════════════════════
 // Phase 4 — MCP Server Management