@miphamai/cli 0.6.8 → 0.6.9

package/package.json

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

package/src/index.tsx

@@ -4,6 +4,7 @@ import { App } from './ui/app'
 import { loadConfig } from './config/loader'
 import { bootstrapProviders } from './providers/bootstrap'
 import { InstructionsLoader } from './core/instructions'
+import { loadSessionMemories } from './core/memory/memory-loader'
 import { ContextManager } from './core/context'
 import { QueryEngine } from './core/engine'
 import { SessionStore } from './core/session-store'
@@ -93,7 +94,9 @@ export async function runApp(options: RunOptions): Promise<void> {
   }
 
   if (context.getMessageCount() === 0) {
-    context.setSystemPrompt(instructions.buildSystemPrompt())
+    const basePrompt = instructions.buildSystemPrompt()
+    const memoryReminder = loadSessionMemories(basePrompt)
+    context.setSystemPrompt(memoryReminder ? `${basePrompt}\n\n${memoryReminder}` : basePrompt)
   }
 
   // Create tool registry with all built-in tools

package/src/tools/agent/memory.ts

@@ -4,6 +4,23 @@ import type { ToolDefinition } from '../../shared/index.ts'
 
 const MEMORY_DIR = join(process.env.HOME || '~', '.mipham', 'memory')
 
+/**
+ * Format a memory file with frontmatter, compatible with MemoryManager.parseMemoryFile.
+ */
+function formatMemory(name: string, content: string): string {
+  const desc = content.slice(0, 80).replace(/\n/g, ' ')
+  return `---
+name: ${name}
+description: ${desc}
+metadata:
+  type: reference
+  relevance: []
+---
+
+${content}
+`
+}
+
 export const memoryTool: ToolDefinition = {
   name: 'Memory',
   description: 'Read and write persistent memory files in ~/.mipham/memory/.',
@@ -27,7 +44,7 @@ export const memoryTool: ToolDefinition = {
     mkdirSync(MEMORY_DIR, { recursive: true })
 
     if (action === 'list') {
-      const files = readdirSync(MEMORY_DIR).filter((f) => f.endsWith('.md'))
+      const files = readdirSync(MEMORY_DIR).filter((f) => f.endsWith('.md') && f !== 'MEMORY.md')
       return { success: true, content: files.join('\n') || '(no memories)' }
     }
 
@@ -42,7 +59,8 @@ export const memoryTool: ToolDefinition = {
     }
 
     if (action === 'write') {
-      writeFileSync(filePath, params.content as string, 'utf-8')
+      const body = formatMemory(name, params.content as string)
+      writeFileSync(filePath, body, 'utf-8')
       return { success: true, content: `Memory "${name}" written` }
     }
 

package/src/tools/agent/workflow.ts

@@ -0,0 +1,58 @@
+import type { ToolDefinition } from '../../shared/index.ts'
+import { runWorkflow } from '../../workflow/runtime'
+import type { QueryEngine } from '../../core/engine'
+
+export const workflowTool: ToolDefinition = {
+  name: 'Workflow',
+  description:
+    'Execute a multi-agent workflow script. The script uses agent(), parallel(), pipeline(), phase(), log(), args, budget primitives. Use for complex orchestrated tasks.',
+  category: 'agent',
+  permission: 'ask',
+  parameters: {
+    type: 'object',
+    properties: {
+      script: {
+        type: 'string',
+        description:
+          'JavaScript workflow script using agent/parallel/pipeline/phase/log/args/budget primitives',
+      },
+      args: {
+        type: 'object',
+        description: 'Arguments to pass to the workflow script as the `args` global',
+      },
+    },
+    required: ['script'],
+  },
+  async execute(params, ctx) {
+    const script = params.script as string
+    const args = (params.args as Record<string, unknown>) || {}
+
+    if (!ctx.registry || !ctx.toolRegistry) {
+      return {
+        success: false,
+        content: '',
+        error: 'Workflow execution requires an active provider and tool registry.',
+      }
+    }
+
+    // Build a minimal engine-like interface for runWorkflow
+    const engineStub = {
+      getRegistry: () => ctx.registry!,
+      getTools: () => ctx.toolRegistry!,
+    } as QueryEngine
+
+    try {
+      const { runId, result } = await runWorkflow(script, engineStub, args)
+      return {
+        success: true,
+        content: `Workflow ${runId} completed.\n\nResult:\n${typeof result === 'string' ? result : JSON.stringify(result, null, 2)}`,
+      }
+    } catch (err) {
+      return {
+        success: false,
+        content: '',
+        error: `Workflow execution failed: ${String(err)}`,
+      }
+    }
+  },
+}

package/src/tools/index.ts

@@ -11,6 +11,7 @@ import { agentTool } from './agent/agent'
 import { skillTool } from './agent/skill'
 import { planTool } from './agent/plan'
 import { memoryTool } from './agent/memory'
+import { workflowTool } from './agent/workflow'
 import { webFetchTool } from './network/web-fetch'
 import { webSearchTool } from './network/web-search'
 import { configTool } from './system/config'
@@ -112,6 +113,7 @@ export function createToolRegistry(): Map<string, ToolDefinition> {
     withValidation(skillTool),
     withValidation(planTool),
     withValidation(memoryTool),
+    withValidation(workflowTool),
     // Network tools
     withValidation(webFetchTool),
     withValidation(webSearchTool),