@miphamai/cli 0.6.3 → 0.6.5

package/package.json

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

package/src/core/engine.ts

@@ -8,12 +8,14 @@ import type { AgentRegistry } from '../agent/agent-registry'
 import { analyzeForMemory } from './memory/memory-writer'
 import { getMemoryManager } from './memory/memory-loader'
 import type { AgentViewManager } from '../agent-view/agent-view-manager'
+import type { SkillsLoader } from '../skills/loader'
 
 export class QueryEngine {
   private hookEngine?: HookEngine
   private artifactServer?: ArtifactServer
   private agentRegistry?: AgentRegistry
   private agentViewManager?: AgentViewManager
+  private skillsLoader?: SkillsLoader
   private goal?: string
   private maxGoalLoops = 20
   private lastAssistantContent?: string
@@ -55,6 +57,11 @@ export class QueryEngine {
     return this.agentViewManager
   }
 
+  /** Register the SkillsLoader for Skill tool context injection. */
+  setSkillsLoader(loader: SkillsLoader): void {
+    this.skillsLoader = loader
+  }
+
   /** Set the session goal for goal-driven execution. */
   setGoal(goal: string): void {
     this.goal = goal
@@ -393,6 +400,7 @@ export class QueryEngine {
         sessionId: 'session-1',
         provider: this.registry.getActive().config.id,
         model: this.registry.getActiveModel(),
+        skillsLoader: this.skillsLoader,
         registry: this.registry,
         toolRegistry: this.tools,
         artifactServer: this.artifactServer,
@@ -431,6 +439,27 @@ export class QueryEngine {
     return this.tools
   }
 
+  /** Register a tool dynamically (used by MCP auto-registration). */
+  registerTool(tool: ToolDefinition): void {
+    if (this.tools.has(tool.name)) {
+      process.stderr.write(`[mcp] Tool collision: "${tool.name}" already registered. Skipping.\n`)
+      return
+    }
+    this.tools.set(tool.name, tool)
+  }
+
+  /** Remove a dynamically registered tool by name. */
+  unregisterTool(name: string): void {
+    this.tools.delete(name)
+  }
+
+  /** Register multiple tools at once. */
+  registerTools(tools: ToolDefinition[]): void {
+    for (const tool of tools) {
+      this.tools.set(tool.name, tool)
+    }
+  }
+
   switchProvider(providerId: string, modelId?: string): void {
     this.registry.switchProvider(providerId, modelId)
   }

package/src/index.tsx

@@ -11,6 +11,7 @@ import { SkillsLoader } from './skills/loader'
 import { PluginManager } from './plugin/plugin-manager'
 import { createToolRegistry } from './tools'
 import { McpClient } from './mcp/client'
+import { registerMcpServerTools } from './mcp/registry'
 import { HookEngine } from './core/hooks'
 import { ArtifactServer } from './artifacts/server'
 import { ARTIFACTS_DIR, ARTIFACT_PORT, MIPHAM_DIR } from './shared/constants'
@@ -50,17 +51,6 @@ export async function runApp(options: RunOptions): Promise<void> {
   // Load configuration
   const config = loadConfig()
 
-  // Connect MCP servers (fire-and-forget — do not block startup)
-  const mcpServers = config.skills?.mcpServers ?? []
-  if (mcpServers.length > 0) {
-    const mcp = McpClient.getInstance()
-    for (const server of mcpServers) {
-      mcp.connect(server).catch((err) => {
-        process.stderr.write(`[mcp] Failed to connect "${server.name}": ${String(err)}\n`)
-      })
-    }
-  }
-
   // Bootstrap providers
   const defaultProvider = options.provider || config.defaultProvider
   const defaultModel = options.model || config.defaultModel
@@ -73,10 +63,17 @@ export async function runApp(options: RunOptions): Promise<void> {
   // Load skills
   const skillsLoader = new SkillsLoader()
   skillsLoader.loadBuiltin(process.cwd())
+  skillsLoader.loadUserSkills()
   if (config.skills?.paths) {
     skillsLoader.loadExternal(config.skills.paths)
   }
 
+  // Inject skills system-reminder into system prompt for AI auto-triggering
+  const skillsReminder = skillsLoader.buildSystemReminder()
+  if (skillsReminder) {
+    instructions.setSkillsReminder(skillsReminder)
+  }
+
   // Initialize plugin manager
   const pluginManager = new PluginManager()
 
@@ -97,9 +94,34 @@ export async function runApp(options: RunOptions): Promise<void> {
     context.setSystemPrompt(instructions.buildSystemPrompt())
   }
 
-  // Create tool registry with all 16 tools
+  // Create tool registry with all built-in tools
   const tools = createToolRegistry()
 
+  // Connect MCP servers and register their tools into the tool registry.
+  // Uses Promise.allSettled for parallel connection — failures are non-fatal.
+  const mcpServers = config.skills?.mcpServers ?? []
+  if (mcpServers.length > 0) {
+    const mcp = McpClient.getInstance()
+    const results = await Promise.allSettled(
+      mcpServers.map(async (server) => {
+        await mcp.connect(server)
+        const count = registerMcpServerTools(server.name, tools)
+        if (count > 0) {
+          process.stderr.write(`[mcp] "${server.name}": registered ${count} tools\n`)
+        }
+      }),
+    )
+    // Log failures (non-fatal — app starts without that server's tools)
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i]!
+      if (result.status === 'rejected') {
+        process.stderr.write(
+          `[mcp] Failed to connect "${mcpServers[i]!.name}": ${String(result.reason)}\n`,
+        )
+      }
+    }
+  }
+
   // Initialize hook engine — register skill-defined hooks
   const hookEngine = new HookEngine()
   for (const skill of skillsLoader.list()) {
@@ -119,6 +141,7 @@ export async function runApp(options: RunOptions): Promise<void> {
   engine.setHookEngine(hookEngine)
   engine.setArtifactServer(artifactServer)
   engine.setAgentViewManager(agentViewManager)
+  engine.setSkillsLoader(skillsLoader)
   engine.setupContextSummarizer()
 
   // Auto-save session on exit

package/src/mcp/registry.ts

@@ -0,0 +1,142 @@
+/**
+ * MCP Tool Registry — converts MCP server tools into main ToolDefinitions
+ * and registers them into the central tool registry.
+ *
+ * Naming convention: mcp__<sanitizedServerName>__<sanitizedToolName>
+ * Example: server "chrome-devtools-mcp" tool "click" → "mcp__chrome_devtools_mcp__click"
+ */
+
+import type { ToolDefinition as McpToolDefinition, ToolCallResult } from './types'
+import type { ToolDefinition, ToolResult, ToolContext } from '../shared/types'
+import { McpClient } from './client'
+
+const MCP_TOOL_PREFIX = 'mcp__'
+const MAX_NAME_LENGTH = 128
+
+/**
+ * Sanitize a name for use in a tool identifier.
+ * Lowercases and replaces non-alphanumeric characters (except hyphens) with underscores.
+ */
+function sanitizeName(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '_')
+    .replace(/_+/g, '_')
+    .replace(/^_|_$/g, '')
+}
+
+/**
+ * Build a namespaced MCP tool name.
+ * Format: mcp__<sanitizedServerName>__<sanitizedToolName>
+ */
+function buildToolName(serverName: string, toolName: string): string {
+  const base = `${MCP_TOOL_PREFIX}${sanitizeName(serverName)}__${sanitizeName(toolName)}`
+  if (base.length <= MAX_NAME_LENGTH) return base
+  const prefix = `${MCP_TOOL_PREFIX}${sanitizeName(serverName)}__`
+  const maxToolLen = MAX_NAME_LENGTH - prefix.length
+  return prefix + sanitizeName(toolName).slice(0, maxToolLen)
+}
+
+/**
+ * Convert an MCP server ToolDefinition into the main ToolDefinition format
+ * that can be registered in the central tool registry.
+ */
+export function convertMcpTool(serverName: string, mcpTool: McpToolDefinition): ToolDefinition {
+  const toolName = buildToolName(serverName, mcpTool.name)
+
+  // Build parameters schema — pass through MCP inputSchema as-is
+  const parameters: Record<string, unknown> = {
+    type: 'object',
+    properties: (mcpTool.inputSchema.properties as Record<string, unknown>) ?? {},
+  }
+  if (mcpTool.inputSchema.required) {
+    parameters.required = mcpTool.inputSchema.required
+  }
+
+  return {
+    name: toolName,
+    description: `[MCP:${serverName}] ${mcpTool.description || mcpTool.name}`,
+    category: 'system',
+    permission: 'ask',
+    parameters,
+    async execute(params: Record<string, unknown>, _ctx: ToolContext): Promise<ToolResult> {
+      const client = McpClient.getInstance()
+
+      const conn = client.getConnection(serverName)
+      if (!conn || conn.status !== 'connected') {
+        return {
+          success: false,
+          content: '',
+          error: `MCP server "${serverName}" is not connected (status: ${conn?.status || 'unknown'}). The server may have crashed or been disconnected.`,
+        }
+      }
+
+      const result: ToolCallResult = await client.callTool(serverName, mcpTool.name, params)
+
+      const text = result.content
+        .map((c) => {
+          if (c.type === 'text' && c.text) return c.text
+          if (c.type === 'image') return `[Image: ${c.mimeType || 'unknown'}]`
+          return JSON.stringify(c)
+        })
+        .join('\n')
+
+      return {
+        success: !result.isError,
+        content: text || '(empty result)',
+        error: result.isError ? text : undefined,
+      }
+    },
+  }
+}
+
+/**
+ * Register all tools from a connected MCP server into the tool registry.
+ * Returns the number of tools registered.
+ */
+export function registerMcpServerTools(
+  serverName: string,
+  toolsMap: Map<string, ToolDefinition>,
+): number {
+  const client = McpClient.getInstance()
+  const mcpTools = client.getTools(serverName)
+  let registered = 0
+
+  for (const mcpTool of mcpTools) {
+    try {
+      const tool = convertMcpTool(serverName, mcpTool)
+
+      if (toolsMap.has(tool.name)) {
+        process.stderr.write(
+          `[mcp] Tool collision: "${tool.name}" (from server "${serverName}") conflicts with existing tool. Skipping.\n`,
+        )
+        continue
+      }
+
+      toolsMap.set(tool.name, tool)
+      registered++
+    } catch (err) {
+      process.stderr.write(
+        `[mcp] Failed to register tool "${mcpTool.name}" from server "${serverName}": ${String(err)}\n`,
+      )
+    }
+  }
+
+  return registered
+}
+
+/**
+ * Unregister all tools previously registered from a specific MCP server.
+ * Tools are identified by the mcp__<serverName>__ prefix.
+ */
+export function unregisterMcpServerTools(
+  serverName: string,
+  toolsMap: Map<string, ToolDefinition>,
+): void {
+  const prefix = `${MCP_TOOL_PREFIX}${sanitizeName(serverName)}__`
+  for (const name of toolsMap.keys()) {
+    if (name.startsWith(prefix)) {
+      toolsMap.delete(name)
+    }
+  }
+}

package/src/shared/types.ts

@@ -147,6 +147,8 @@ export interface SkillDefinition {
   disableModelInvocation?: boolean
   /** When true, users can invoke this skill directly via /<name> */
   userInvocable?: boolean
+  /** The markdown body content of the skill file (instructions for the AI to follow). */
+  body?: string
 }
 
 // ── Hook Types ──

package/src/skills/loader.ts

@@ -98,13 +98,14 @@ export class SkillsLoader {
   private tryLoad(path: string, type: 'standard' | 'mipham'): void {
     try {
       const raw = readFileSync(path, 'utf-8')
-      const { data } = parseFrontmatter(raw)
+      const { data, content } = parseFrontmatter(raw)
 
       const skill: SkillDefinition = {
         name: (data.name as string) || this.nameFromPath(path),
         description: (data.description as string) || '',
         version: (data.version as string) || '0.1.0',
         type,
+        body: content.trim() || undefined,
         tools: data.tools as SkillDefinition['tools'],
         hooks: data.hooks as SkillDefinition['hooks'],
         prompts: data.prompts as SkillDefinition['prompts'],

package/src/tools/agent/skill.ts

@@ -64,15 +64,16 @@ export const skillTool: ToolDefinition = {
         }
       }
 
-      // Standard inline execution — return metadata for AI to follow
+      // Standard inline execution — return skill body for AI to follow
       const lines: string[] = [
         `── Skill Invoked: ${skill.name} ──`,
         `Type: ${skill.type} | Version: ${skill.version}`,
         skill.description ? `Description: ${skill.description}` : '',
         args ? `Arguments: ${args}` : '',
         '',
-        'The AI should now follow the instructions from this skill.',
-        'Skill content has been loaded into context.',
+        'The AI should now follow these instructions:',
+        '',
+        skill.body || '(no instructions body)',
       ].filter(Boolean)
 
       return { success: true, content: lines.join('\n') }