@miphamai/cli 0.6.5 → 0.6.7

package/package.json

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

package/src/agent/sub-agent.ts

@@ -75,24 +75,97 @@ export class SubAgent {
     const resolvedModel = modelToUse === 'inherit' ? model : modelToUse
 
     const chunks: string[] = []
+    const MAX_TOOL_TURNS = options.maxTurns || 5
+
+    let currentMessages = messages
+    let currentSystemPrompt = systemPrompt
 
     try {
-      for await (const chunk of provider.chat({
-        model: resolvedModel,
-        messages,
-        systemPrompt,
-        tools: toolDefs,
-        maxTokens: 4096,
-      })) {
-        if (chunk.type === 'text' && chunk.content) {
-          chunks.push(chunk.content)
-        }
-        if (chunk.type === 'error') {
-          throw new Error(`Sub-agent execution failed: ${chunk.error}`)
+      for (let turn = 0; turn < MAX_TOOL_TURNS; turn++) {
+        const toolUses: Array<{ id: string; name: string; input: Record<string, unknown> }> = []
+        let turnText = ''
+
+        for await (const chunk of provider.chat({
+          model: resolvedModel,
+          messages: currentMessages,
+          systemPrompt: currentSystemPrompt,
+          tools: toolDefs,
+          maxTokens: 4096,
+        })) {
+          if (chunk.type === 'text' && chunk.content) {
+            turnText += chunk.content
+          }
+          if (chunk.type === 'tool_use' && chunk.toolUse) {
+            toolUses.push({
+              id: chunk.toolUse.id,
+              name: chunk.toolUse.name,
+              input: chunk.toolUse.input,
+            })
+          }
+          if (chunk.type === 'error') {
+            throw new Error(`Sub-agent execution failed: ${chunk.error}`)
+          }
+          if (chunk.type === 'stop') {
+            break
+          }
         }
-        if (chunk.type === 'stop') {
-          break
+
+        chunks.push(turnText)
+
+        // No tools used — we're done
+        if (toolUses.length === 0) break
+
+        // Execute tools and build follow-up messages
+        currentMessages = [
+          ...currentMessages,
+          {
+            role: 'assistant' as const,
+            content: turnText || 'Executing tools...',
+          },
+        ]
+
+        for (const tu of toolUses) {
+          const tool = this.toolRegistry.get(tu.name)
+          if (!tool) {
+            currentMessages.push({
+              role: 'user' as const,
+              content: `Error: Unknown tool "${tu.name}"`,
+            })
+            continue
+          }
+
+          try {
+            const result = await tool.execute(tu.input, {
+              cwd: process.cwd(),
+              sessionId: 'sub-agent',
+              provider: '',
+              model: resolvedModel,
+            })
+
+            currentMessages.push({
+              role: 'assistant' as const,
+              content: [{ type: 'tool_use' as const, id: tu.id, name: tu.name, input: tu.input }],
+            })
+            currentMessages.push({
+              role: 'user' as const,
+              content: [
+                {
+                  type: 'tool_result' as const,
+                  tool_use_id: tu.id,
+                  content: result.success ? result.content : result.error || result.content,
+                },
+              ],
+            })
+          } catch (err) {
+            currentMessages.push({
+              role: 'user' as const,
+              content: `Tool "${tu.name}" execution error: ${String(err)}`,
+            })
+          }
         }
+
+        // Don't send system prompt on subsequent turns
+        currentSystemPrompt = ''
       }
     } catch (err) {
       if (err instanceof Error && err.message.startsWith('Sub-agent')) {

package/src/agent/types.ts

@@ -36,4 +36,6 @@ export interface SubAgentOptions {
   maxContextMessages?: number
   allowedTools?: string[]
   modelOverride?: string
+  /** Maximum tool-calling turns (default: 5) to prevent infinite loops. */
+  maxTurns?: number
 }

package/src/index.tsx

@@ -9,9 +9,11 @@ import { QueryEngine } from './core/engine'
 import { SessionStore } from './core/session-store'
 import { SkillsLoader } from './skills/loader'
 import { PluginManager } from './plugin/plugin-manager'
+import { loadPlugins } from './plugin/plugin-loader'
 import { createToolRegistry } from './tools'
 import { McpClient } from './mcp/client'
 import { registerMcpServerTools } from './mcp/registry'
+import { AgentRegistry } from './agent/agent-registry'
 import { HookEngine } from './core/hooks'
 import { ArtifactServer } from './artifacts/server'
 import { ARTIFACTS_DIR, ARTIFACT_PORT, MIPHAM_DIR } from './shared/constants'
@@ -142,6 +144,22 @@ export async function runApp(options: RunOptions): Promise<void> {
   engine.setArtifactServer(artifactServer)
   engine.setAgentViewManager(agentViewManager)
   engine.setSkillsLoader(skillsLoader)
+
+  // Initialize agent registry and load plugin agents/skills/MCP/hooks
+  const agentRegistry = new AgentRegistry()
+  agentRegistry.loadUserAgents()
+  agentRegistry.loadProjectAgents(process.cwd())
+  engine.setAgentRegistry(agentRegistry)
+
+  loadPlugins(
+    pluginManager,
+    agentRegistry,
+    skillsLoader,
+    hookEngine,
+    McpClient.getInstance(),
+    tools,
+  )
+
   engine.setupContextSummarizer()
 
   // Auto-save session on exit

package/src/plugin/plugin-loader.ts

@@ -1,36 +1,116 @@
-import type { PluginManager } from './plugin-manager'
 import { join } from 'node:path'
-import { existsSync } from 'node:fs'
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import type { PluginManager } from './plugin-manager'
+import type { AgentRegistry } from '../agent/agent-registry'
+import type { SkillsLoader } from '../skills/loader'
+import type { HookEngine } from '../core/hooks'
+import type { McpClient } from '../mcp/client'
+import { registerMcpServerTools } from '../mcp/registry'
+import { executeHook } from '../core/hooks-executor'
+import type { McpServerConfig, ToolDefinition, HookConfig, HookEvent } from '../shared/types'
 
+/**
+ * Activate all enabled plugins — load their agents, skills, MCP servers, and hooks.
+ *
+ * Called once at startup after the core subsystems (agent registry, skills loader,
+ * hook engine, MCP client, tool registry) are initialized.
+ */
 export function loadPlugins(
   pluginManager: PluginManager,
-  engine: unknown,
-  skillsLoader: unknown,
+  agentRegistry: AgentRegistry,
+  skillsLoader: SkillsLoader,
+  hookEngine: HookEngine,
+  mcpClient: McpClient,
+  toolsMap: Map<string, ToolDefinition>,
 ): void {
   for (const plugin of pluginManager.getEnabled()) {
-    // Load custom agents
+    // ── Custom agents ──
     const agentsDir = join(plugin.path, 'agents')
     if (existsSync(agentsDir)) {
-      // → register with AgentRegistry
+      try {
+        agentRegistry.loadDirectory(agentsDir, 'user')
+      } catch (err) {
+        process.stderr.write(
+          `[plugin] Failed to load agents from "${plugin.name}": ${String(err)}\n`,
+        )
+      }
     }
 
-    // Load custom skills
+    // ── Custom skills ──
     const skillsDir = join(plugin.path, 'skills')
     if (existsSync(skillsDir)) {
-      // → register with SkillsLoader
+      try {
+        skillsLoader.loadExternal([skillsDir])
+      } catch (err) {
+        process.stderr.write(
+          `[plugin] Failed to load skills from "${plugin.name}": ${String(err)}\n`,
+        )
+      }
     }
 
-    // Load MCP servers
+    // ── MCP servers ──
     const mcpDir = join(plugin.path, 'mcp-servers')
     if (existsSync(mcpDir)) {
-      // → register MCP configs
+      try {
+        const entries = readdirSync(mcpDir)
+        for (const entry of entries) {
+          if (!entry.endsWith('.json')) continue
+          try {
+            const raw = readFileSync(join(mcpDir, entry), 'utf-8')
+            const cfg = JSON.parse(raw) as McpServerConfig
+            if (cfg.name && cfg.command) {
+              mcpClient
+                .connect(cfg)
+                .then(() => {
+                  const count = registerMcpServerTools(cfg.name, toolsMap)
+                  if (count > 0) {
+                    process.stderr.write(
+                      `[plugin] "${plugin.name}": registered ${count} MCP tools from "${cfg.name}"\n`,
+                    )
+                  }
+                })
+                .catch((err: unknown) => {
+                  process.stderr.write(
+                    `[plugin] Failed to connect MCP "${cfg.name}" from "${plugin.name}": ${String(err)}\n`,
+                  )
+                })
+            }
+          } catch {
+            // skip unparseable MCP config files
+          }
+        }
+      } catch (err) {
+        process.stderr.write(
+          `[plugin] Failed to load MCP configs from "${plugin.name}": ${String(err)}\n`,
+        )
+      }
     }
 
-    // Load hooks
-    // → parse plugin.json hooks → register with HookEngine
+    // ── Hooks from plugin.json ──
+    // Plugin hooks are HookConfig objects (type + command/url), not HookDefinition
+    // (which requires a handler function). Convert them via executeHook wrapper.
+    try {
+      const manifestPath = join(plugin.path, 'plugin.json')
+      if (existsSync(manifestPath)) {
+        const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'))
+        if (manifest.hooks && Array.isArray(manifest.hooks)) {
+          for (const hookCfg of manifest.hooks as HookConfig[]) {
+            if (hookCfg.type && hookCfg) {
+              const event = (hookCfg as unknown as Record<string, unknown>).event as
+                | HookEvent
+                | undefined
+              if (event) {
+                hookEngine.register({
+                  event,
+                  handler: async (ctx) => executeHook(hookCfg, ctx),
+                })
+              }
+            }
+          }
+        }
+      }
+    } catch (err) {
+      process.stderr.write(`[plugin] Failed to load hooks from "${plugin.name}": ${String(err)}\n`)
+    }
   }
-
-  // Suppress unused parameter warnings — these are wiring stubs for future phases
-  void engine
-  void skillsLoader
 }

package/src/ui/app.tsx

@@ -97,10 +97,14 @@ export function App({
 
   // Initialize agent registry (one-time, on mount)
   useMemo(() => {
-    const agentRegistry = new AgentRegistry()
-    agentRegistry.loadUserAgents()
-    agentRegistry.loadProjectAgents(process.cwd())
-    engine.setAgentRegistry(agentRegistry)
+    // Agent registry may already be initialized in index.tsx (for plugin loading).
+    // Only create a fresh one if not already set on the engine.
+    if (!engine.getAgentRegistry()) {
+      const agentRegistry = new AgentRegistry()
+      agentRegistry.loadUserAgents()
+      agentRegistry.loadProjectAgents(process.cwd())
+      engine.setAgentRegistry(agentRegistry)
+    }
   }, [])
 
   const mkCtx = useCallback(