@miphamai/cli 0.3.0 → 0.5.0

package/src/ui/input.tsx

@@ -1,6 +1,7 @@
 import React, { useState, useEffect, useRef } from 'react'
-import { Box, Text } from 'ink'
+import { Box, Text, useInput } from 'ink'
 import TextInput from 'ink-text-input'
+import { VimMotionEngine, type VimMode } from './vim-motions.js'
 
 interface InputBarProps {
   onSubmit: (input: string) => void
@@ -10,34 +11,95 @@ interface InputBarProps {
 // ── Status verbs — English (Claude Code-aligned) + Chinese (Mipham originals) ──
 
 const STATUS_EN = [
-  'Doodling', 'Forging', 'Germinating', 'Mosmosing', 'Cerebrating',
-  'Boogieing', 'Finagling', 'Misting', 'Recombobulating', 'Slithering',
-  'Effecting', 'Roosting', 'Crystallizing', 'Canoodling', 'Billowing',
-  'Warping', 'Improvising', 'Metamorphing', 'Gusting', 'Whiring',
-  'Topsy-turvying', 'Flibbertigibetting', 'Wibbling', 'Thundering',
-  'Moseying', 'Julienning', 'Evaporating', 'Ruminating', 'Whisking',
-  'Scampering', 'Meandering', 'Concoting', 'Gesticulating', 'Flamebeing',
-  'Quantumizing', 'Waddling', 'Fluttering', 'Sprouting', 'Elucidating',
-  'Embellishing', 'Razzmatizing', 'Pondering', 'Cogitating', 'Garnishing',
-  'Actualizing', 'Zigzagging', 'Mustering', 'Frolicking', 'Hullaballooing',
-  'Doing', 'Fermenting', 'Considering', 'Skedaddling', 'Actioning',
-  'Orbiting', 'Perambulating', 'Drizzling', 'Schlepping', 'Ionizing',
+  'Doodling',
+  'Forging',
+  'Germinating',
+  'Mosmosing',
+  'Cerebrating',
+  'Boogieing',
+  'Finagling',
+  'Misting',
+  'Recombobulating',
+  'Slithering',
+  'Effecting',
+  'Roosting',
+  'Crystallizing',
+  'Canoodling',
+  'Billowing',
+  'Warping',
+  'Improvising',
+  'Metamorphing',
+  'Gusting',
+  'Whiring',
+  'Topsy-turvying',
+  'Flibbertigibetting',
+  'Wibbling',
+  'Thundering',
+  'Moseying',
+  'Julienning',
+  'Evaporating',
+  'Ruminating',
+  'Whisking',
+  'Scampering',
+  'Meandering',
+  'Concoting',
+  'Gesticulating',
+  'Flamebeing',
+  'Quantumizing',
+  'Waddling',
+  'Fluttering',
+  'Sprouting',
+  'Elucidating',
+  'Embellishing',
+  'Razzmatizing',
+  'Pondering',
+  'Cogitating',
+  'Garnishing',
+  'Actualizing',
+  'Zigzagging',
+  'Mustering',
+  'Frolicking',
+  'Hullaballooing',
+  'Doing',
+  'Fermenting',
+  'Considering',
+  'Skedaddling',
+  'Actioning',
+  'Orbiting',
+  'Perambulating',
+  'Drizzling',
+  'Schlepping',
+  'Ionizing',
   'Scurrying',
 ]
 
 const STATUS_CN = [
-  '思忖中', '推演中', '凝炼中', '熬煮中', '锻造中',
-  '研磨中', '解构中', '冥思中', '编织中', '萃取中',
-  '烹制中', '淬火中', '雕琢中', '融汇中', '觉照中',
-  '运转中', '参详中', '化合中', '浸润中', '焙烤中',
+  '思忖中',
+  '推演中',
+  '凝炼中',
+  '熬煮中',
+  '锻造中',
+  '研磨中',
+  '解构中',
+  '冥思中',
+  '编织中',
+  '萃取中',
+  '烹制中',
+  '淬火中',
+  '雕琢中',
+  '融汇中',
+  '觉照中',
+  '运转中',
+  '参详中',
+  '化合中',
+  '浸润中',
+  '焙烤中',
 ]
 
 // Merge both — bilingual status verbs
 const STATUS_GERUNDS = [...STATUS_EN, ...STATUS_CN]
 
-const STATUS_PAST = [
-  'Brewed', 'Churned', 'Cooked', 'Sautéed', 'Cogitated', 'Crunched',
-]
+const STATUS_PAST = ['Brewed', 'Churned', 'Cooked', 'Sautéed', 'Cogitated', 'Crunched']
 
 function pick<T>(arr: T[]): T {
   return arr[Math.floor(Math.random() * arr.length)]!
@@ -76,6 +138,110 @@ export function InputBar({ onSubmit, isLoading }: InputBarProps) {
     prevLoading.current = isLoading
   }, [isLoading])
 
+  const [vimMode, setVimMode] = useState<VimMode>('insert')
+  // NOTE: Dual mode state — React state (vimMode) drives UI re-renders (prompt color,
+  // placeholder); engine mode (vimEngine.current.mode) drives logic inside useInput so
+  // the handler always reads the authoritative mode without stale-closure risk.
+  const vimEngine = useRef(new VimMotionEngine())
+  const vimPending = useRef<string | null>(null)
+  const [searchMode, setSearchMode] = useState(false)
+  const [searchQuery, setSearchQuery] = useState('')
+
+  // ── Vim motions: intercept keys in normal mode ──
+
+  useInput((input, key) => {
+    // Escape toggles between insert and normal mode
+    if (key.escape) {
+      // Cancel search mode if active
+      if (searchMode) {
+        setSearchMode(false)
+        setSearchQuery('')
+        return
+      }
+      // Clear any pending multi-key sequence
+      if (vimPending.current) {
+        vimPending.current = null
+      }
+      setVimMode((prev) => (prev === 'insert' ? 'normal' : 'insert'))
+      vimEngine.current.mode = vimEngine.current.mode === 'insert' ? 'normal' : 'insert'
+      return
+    }
+
+    if (vimEngine.current.mode !== 'normal') return
+
+    // Handle search mode — collect query characters
+    if (searchMode) {
+      if (key.return) {
+        const action = vimEngine.current.handleSearch(value, searchQuery)
+        if (action.text !== undefined) setValue(action.text)
+        // NOTE: action.cursor is not settable on ink-text-input — user repositions manually
+        setSearchMode(false)
+        setSearchQuery('')
+        return
+      }
+      if (key.backspace || key.delete) {
+        setSearchQuery((q) => q.slice(0, -1))
+        return
+      }
+      // Accumulate printable characters
+      if (input && input.length === 1 && !key.escape && !key.return) {
+        setSearchQuery((q) => q + input)
+      }
+      return
+    }
+
+    // Handle pending two-key sequences (dd, yy)
+    if (vimPending.current !== null) {
+      if (vimPending.current === 'd' && input === 'd') {
+        const action = vimEngine.current.handleDD(value)
+        setValue(action.text ?? value)
+      } else if (vimPending.current === 'y' && input === 'y') {
+        vimEngine.current.handleYY(value)
+      }
+      // Always clear pending — even when second key doesn't match
+      vimPending.current = null
+      return
+    }
+
+    // Handle p (paste) — pastes clipboard at cursor position
+    if (input === 'p') {
+      const action = vimEngine.current.handlePaste(value, value.length)
+      if (action.text !== undefined) setValue(action.text)
+      return
+    }
+
+    // Handle u (undo)
+    if (input === 'u') {
+      const action = vimEngine.current.handleUndo(value)
+      if (action.text !== undefined) setValue(action.text)
+      return
+    }
+
+    // Handle / (enter search mode)
+    if (input === '/') {
+      setSearchMode(true)
+      setSearchQuery('')
+      return
+    }
+
+    // Handle single-key motions (h, j, k, l, w, b, 0, $, d, y)
+    const action = vimEngine.current.handleNormal(input, value, value.length)
+    if (!action) return
+
+    if (action.pending) {
+      vimPending.current = action.pending
+      return
+    }
+
+    if (action.text !== undefined) {
+      setValue(action.text)
+    }
+
+    // NOTE: action.cursor is returned by motions (h/j/k/l/w/b/0/$) but
+    // ink-text-input does not expose a programmatic cursor-position API.
+    // The cursor hint is informational only; the user repositions manually.
+  })
+
   const handleSubmit = (val: string) => {
     if (!val.trim() || isLoading) return
     onSubmit(val)
@@ -85,18 +251,28 @@ export function InputBar({ onSubmit, isLoading }: InputBarProps) {
   return (
     <Box marginTop={1}>
       <Box marginRight={1}>
-        <Text color={isLoading ? 'yellow' : 'cyan'}>{'>'}</Text>
+        <Text color={vimMode === 'normal' ? 'magenta' : isLoading ? 'yellow' : 'cyan'}>
+          {vimMode === 'normal' ? ':' : '>'}
+        </Text>
       </Box>
       <TextInput
         value={value}
-        onChange={setValue}
+        onChange={(val) => {
+          // Block text changes during search mode — keys go to search query
+          if (searchMode) return
+          setValue(val)
+        }}
         onSubmit={handleSubmit}
         placeholder={
-          isLoading
-            ? `${verb}...`
-            : completionVerb
-              ? completionVerb
-              : 'Type a message (Esc to cancel)...'
+          searchMode
+            ? `/${searchQuery}`
+            : vimMode === 'normal'
+              ? '[NORMAL] h/j/k/l w/b 0/$ dd yy p u / (Esc to insert)'
+              : isLoading
+                ? `${verb}...`
+                : completionVerb
+                  ? completionVerb
+                  : 'Type a message (Esc to cancel)...'
         }
       />
     </Box>

package/src/ui/picker.tsx

@@ -1,6 +1,6 @@
-import React, { useState, useCallback, useEffect } from 'react'
+import React, { useState, useCallback } from 'react'
 import { Box, Text, useInput } from 'ink'
-import type { MiphamConfig, ProviderConfig, ModelInfo } from '../shared/index.ts'
+import type { MiphamConfig, ProviderConfig } from '../shared/index.ts'
 
 interface PickerProps {
   config: MiphamConfig
@@ -113,9 +113,6 @@ export function ModelPicker({
   // Provider labels
   const providerColor = (p: ProviderConfig) => (p.id === currentProvider ? 'green' : 'white')
 
-  const modelColor = (m: ModelInfo) =>
-    selectedProvider?.id === currentProvider && m.id === currentModel ? 'green' : 'white'
-
   return (
     <Box flexDirection="column" borderStyle="round" borderColor="cyan" padding={1}>
       {/* Title */}

package/src/ui/vim-motions.ts

@@ -0,0 +1,96 @@
+export type VimMode = 'insert' | 'normal'
+
+export class VimMotionEngine {
+  mode: VimMode = 'insert'
+  private clipboard = ''
+  private undoStack: string[] = []
+
+  /** Handle a keypress in normal mode. Returns new cursor position delta and any text mutation. */
+  handleNormal(key: string, text: string, cursor: number): VimAction | null {
+    switch (key) {
+      case 'h':
+        return { cursor: cursor - 1 }
+      case 'j':
+        return { cursor: text.length } // end of line (like $)
+      case 'k':
+        return { cursor: 0 } // start of line (like 0)
+      case 'l':
+        return { cursor: cursor + 1 }
+      case '0':
+        return { cursor: 0 }
+      case '$':
+        return { cursor: text.length }
+      case 'w':
+        return { cursor: this.nextWord(text, cursor) }
+      case 'b':
+        return { cursor: this.prevWord(text, cursor) }
+      case 'd':
+        return { pending: 'd' }
+      case 'y':
+        return { pending: 'y' }
+      default:
+        return null
+    }
+  }
+
+  /** Handle dd — delete entire line */
+  handleDD(text: string): VimAction {
+    this.clipboard = text
+    this.pushUndo(text)
+    return { text: '', cursor: 0 }
+  }
+
+  /** Handle yy — yank entire line */
+  handleYY(text: string): VimAction {
+    this.clipboard = text
+    return { cursor: 0 } // no change
+  }
+
+  /** Handle p — paste after cursor */
+  handlePaste(text: string, cursor: number): VimAction {
+    const newText = text.slice(0, cursor) + this.clipboard + text.slice(cursor)
+    this.pushUndo(text)
+    return { text: newText, cursor: cursor + this.clipboard.length }
+  }
+
+  /** Handle u — undo */
+  handleUndo(text: string): VimAction {
+    const prev = this.undoStack.pop()
+    if (prev !== undefined) {
+      return { text: prev, cursor: prev.length }
+    }
+    return { cursor: text.length }
+  }
+
+  /** Handle /search */
+  handleSearch(text: string, query: string): VimAction {
+    const idx = text.indexOf(query)
+    return idx >= 0 ? { cursor: idx } : { cursor: 0 }
+  }
+
+  private nextWord(text: string, cursor: number): number {
+    // Skip word characters, then skip whitespace
+    let i = cursor
+    while (i < text.length && text[i] !== ' ') i++
+    while (i < text.length && text[i] === ' ') i++
+    return i
+  }
+
+  private prevWord(text: string, cursor: number): number {
+    let i = cursor - 1
+    while (i > 0 && text[i] === ' ') i--
+    while (i > 0 && text[i] !== ' ') i--
+    return i > 0 ? i + 1 : 0
+  }
+
+  private pushUndo(text: string): void {
+    this.undoStack.push(text)
+    if (this.undoStack.length > 50) this.undoStack.shift()
+  }
+}
+
+export interface VimAction {
+  text?: string
+  cursor?: number
+  pending?: string
+}

package/src/workflow/budget.ts

@@ -0,0 +1,33 @@
+export interface Budget {
+  total: number | null
+  spent(): number
+  remaining(): number
+  consume(tokens: number): void
+}
+
+/**
+ * Create a token budget tracker.
+ * If totalTokens is null, the budget is unlimited.
+ */
+export function createBudget(totalTokens: number | null): Budget {
+  let spent = 0
+
+  return {
+    total: totalTokens,
+
+    spent(): number {
+      return spent
+    },
+
+    remaining(): number {
+      return totalTokens === null ? Infinity : Math.max(0, totalTokens - spent)
+    },
+
+    consume(tokens: number): void {
+      spent += tokens
+      if (totalTokens !== null && spent >= totalTokens) {
+        throw new Error('Token budget exceeded')
+      }
+    },
+  }
+}

package/src/workflow/journal.ts

@@ -0,0 +1,105 @@
+import {
+  mkdirSync,
+  writeFileSync,
+  readFileSync,
+  existsSync,
+  appendFileSync,
+  readdirSync,
+} from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+
+const WORKFLOW_DIR = join(homedir(), '.mipham', 'workflows')
+
+export interface JournalEntry {
+  seq: number
+  type: 'agent' | 'phase' | 'log'
+  prompt?: string
+  opts?: Record<string, unknown>
+  result?: unknown
+  message?: string
+}
+
+export interface JournalState {
+  seq: number
+  phases: string[]
+}
+
+/**
+ * Create a journal for a workflow run.
+ * Returns the path to the run directory.
+ */
+export function createJournal(runId: string, script: string): string {
+  const dir = join(WORKFLOW_DIR, runId)
+  mkdirSync(dir, { recursive: true })
+
+  writeFileSync(join(dir, 'script.js'), script, 'utf-8')
+  writeFileSync(join(dir, 'journal.jsonl'), '', 'utf-8')
+  writeFileSync(join(dir, 'state.json'), JSON.stringify({ seq: 0, phases: [] }), 'utf-8')
+
+  return dir
+}
+
+/**
+ * Append an agent call to the journal. Returns the new sequence number.
+ */
+export function appendJournal(runId: string, entry: Omit<JournalEntry, 'seq'>): number {
+  const dir = join(WORKFLOW_DIR, runId)
+  const state = readState(runId)
+
+  const seq = state.seq + 1
+  const fullEntry: JournalEntry = { seq, ...entry }
+
+  appendFileSync(join(dir, 'journal.jsonl'), JSON.stringify(fullEntry) + '\n', 'utf-8')
+
+  state.seq = seq
+  writeFileSync(join(dir, 'state.json'), JSON.stringify(state), 'utf-8')
+
+  return seq
+}
+
+/**
+ * Load all journal entries for a run. Returns empty array if run not found.
+ */
+export function loadJournal(runId: string): JournalEntry[] {
+  const journalPath = join(WORKFLOW_DIR, runId, 'journal.jsonl')
+  if (!existsSync(journalPath)) return []
+
+  const raw = readFileSync(journalPath, 'utf-8')
+  return raw
+    .split('\n')
+    .filter((line) => line.trim())
+    .map((line) => JSON.parse(line) as JournalEntry)
+}
+
+function readState(runId: string): JournalState {
+  const statePath = join(WORKFLOW_DIR, runId, 'state.json')
+  if (!existsSync(statePath)) return { seq: 0, phases: [] }
+  return JSON.parse(readFileSync(statePath, 'utf-8'))
+}
+
+/**
+ * Load the saved script for a run. Returns empty string if not found.
+ */
+export function loadScript(runId: string): string {
+  const scriptPath = join(WORKFLOW_DIR, runId, 'script.js')
+  if (!existsSync(scriptPath)) return ''
+  return readFileSync(scriptPath, 'utf-8')
+}
+
+/**
+ * List all workflow run IDs.
+ */
+export function listRuns(): string[] {
+  if (!existsSync(WORKFLOW_DIR)) return []
+  return readdirSync(WORKFLOW_DIR, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name)
+}
+
+/**
+ * Get the journal directory path for a run.
+ */
+export function getRunDir(runId: string): string {
+  return join(WORKFLOW_DIR, runId)
+}

package/src/workflow/primitives/agent.ts

@@ -0,0 +1,51 @@
+import { SubAgent } from '../../agent/sub-agent'
+import type { ProviderRegistry } from '../../providers/registry'
+import type { ToolDefinition } from '../../shared/index.ts'
+
+export interface WorkflowAgentOpts {
+  label?: string
+  phase?: string
+  schema?: object
+  model?: string
+  provider?: string
+  effort?: 'low' | 'medium' | 'high' | 'max'
+}
+
+/**
+ * Workflow agent() primitive — creates a SubAgent with optional
+ * provider/model override and structured output schema.
+ */
+export async function workflowAgent(
+  prompt: string,
+  registry: ProviderRegistry,
+  toolRegistry: Map<string, ToolDefinition>,
+  opts: WorkflowAgentOpts = {},
+): Promise<unknown> {
+  // If provider override, switch temporarily
+  if (opts.provider) {
+    registry.switchProvider(opts.provider, opts.model)
+  } else if (opts.model) {
+    registry.switchProvider(registry.getActive().config.id, opts.model)
+  }
+
+  const sub = new SubAgent(registry, toolRegistry)
+  const result = await sub.execute(prompt, opts.label || 'workflow-agent', {
+    type: 'general',
+    modelOverride: opts.model,
+    allowedTools: undefined, // use all tools by default
+  })
+
+  // If schema is provided, attempt to parse the result as JSON
+  if (opts.schema) {
+    try {
+      const parsed = JSON.parse(result)
+      // Basic validation: return parsed object
+      return parsed
+    } catch {
+      // Return raw text if JSON parse fails
+      return { raw: result }
+    }
+  }
+
+  return result
+}

package/src/workflow/primitives/parallel.ts

@@ -0,0 +1,8 @@
+/**
+ * parallel() — barrier: executes all thunks concurrently, waits for all.
+ * Failed thunks resolve to null. Never throws.
+ */
+export async function parallel<T>(thunks: Array<() => Promise<T>>): Promise<(T | null)[]> {
+  const results = await Promise.allSettled(thunks.map((t) => t()))
+  return results.map((r) => (r.status === 'fulfilled' ? r.value : null))
+}

package/src/workflow/primitives/phase.ts

@@ -0,0 +1,19 @@
+let currentPhase: string = ''
+
+/**
+ * Set the current workflow phase title.
+ * In a real implementation, this emits to a progress tracker.
+ */
+export function phase(title: string): void {
+  currentPhase = title
+}
+
+/** Get the current workflow phase title. */
+export function getCurrentPhase(): string {
+  return currentPhase
+}
+
+/** Reset the current phase state (useful for testing). */
+export function resetPhase(): void {
+  currentPhase = ''
+}

package/src/workflow/primitives/pipeline.ts

@@ -0,0 +1,24 @@
+/**
+ * pipeline() — no barrier: each item flows through all stages independently.
+ * Item A can be in stage 3 while item B is still in stage 1.
+ * Failed items become null and skip remaining stages.
+ */
+export async function pipeline<T, R>(
+  items: T[],
+  ...stages: Array<(item: T, index: number, original: T) => Promise<R>>
+): Promise<(R | null)[]> {
+  // Process each item through all stages concurrently
+  return Promise.all(
+    items.map(async (item, index) => {
+      let current: unknown = item
+      for (const stage of stages) {
+        try {
+          current = await stage(current as T, index, item)
+        } catch {
+          return null // item failed, skip remaining stages
+        }
+      }
+      return current as R
+    }),
+  )
+}