@miphamai/cli 0.6.4 → 0.6.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "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,

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'
@@ -63,10 +65,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()
 
@@ -134,6 +143,23 @@ export async function runApp(options: RunOptions): Promise<void> {
   engine.setHookEngine(hookEngine)
   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,105 @@
-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 type { McpServerConfig, ToolDefinition, HookDefinition } 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 ──
+    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 hook of manifest.hooks as HookDefinition[]) {
+            if (hook.event) {
+              hookEngine.register(hook)
+            }
+          }
+        }
+      }
+    } 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/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') }

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(