@miphamai/cli 0.4.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
@@ -137,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)
@@ -146,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/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
+    }),
+  )
+}

package/src/workflow/runtime.ts

@@ -0,0 +1,87 @@
+import { createSandbox } from './sandbox'
+import { createJournal, appendJournal } from './journal'
+import { createBudget } from './budget'
+import { workflowAgent } from './primitives/agent'
+import { parallel } from './primitives/parallel'
+import { pipeline } from './primitives/pipeline'
+import { phase as phasePrimitive } from './primitives/phase'
+import type { ProviderRegistry } from '../providers/registry'
+import type { QueryEngine } from '../core/engine'
+
+export interface WorkflowRunResult {
+  runId: string
+  result: unknown
+  journalEntries: number
+}
+
+/**
+ * Execute a workflow script string.
+ *
+ * The script is evaluated in a sandboxed context with the workflow
+ * primitives (agent, parallel, pipeline, phase, args, budget) injected.
+ */
+export async function runWorkflow(
+  script: string,
+  engine: QueryEngine,
+  args: unknown = {},
+  budgetTotal: number | null = null,
+): Promise<WorkflowRunResult> {
+  const runId = `run-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`
+  createJournal(runId, script)
+
+  const registry: ProviderRegistry = engine.getRegistry()
+  const toolRegistry = engine.getTools()
+
+  const budget = createBudget(budgetTotal)
+
+  // Wrap primitives with journal recording
+  const agent = async (prompt: string, opts?: Record<string, unknown>) => {
+    const result = await workflowAgent(
+      prompt,
+      registry,
+      toolRegistry,
+      opts as Record<string, unknown>,
+    )
+    appendJournal(runId, {
+      type: 'agent',
+      prompt,
+      opts: opts as Record<string, unknown> | undefined,
+      result,
+    })
+    return result
+  }
+
+  const wrappedPhase = (title: string) => {
+    phasePrimitive(title)
+    appendJournal(runId, { type: 'phase', message: title })
+  }
+
+  const log = (message: string) => {
+    appendJournal(runId, { type: 'log', message })
+  }
+
+  const sandbox = createSandbox(args, budget)
+
+  // Build the script wrapper
+  const wrappedScript = `
+    return (async () => {
+      ${script}
+    })()
+  `
+
+  // Execute in sandboxed context
+  const scriptFn = new Function(
+    'agent',
+    'parallel',
+    'pipeline',
+    'phase',
+    'log',
+    'args',
+    'budget',
+    wrappedScript,
+  )
+
+  const result = await scriptFn(agent, parallel, pipeline, wrappedPhase, log, args, budget)
+
+  return { runId, result, journalEntries: 0 }
+}

package/src/workflow/sandbox.ts

@@ -0,0 +1,75 @@
+/** APIs disabled in workflow scripts to ensure deterministic replay. */
+const FORBIDDEN = new Set(['Date.now', 'Math.random', 'crypto.randomUUID'])
+
+/**
+ * Create a sandboxed global scope for workflow script execution.
+ * Blocks Date.now(), Math.random(), argless new Date(), crypto.randomUUID().
+ */
+export function createSandbox(
+  args: unknown,
+  budget: { total: number | null; spent(): number; remaining(): number },
+): Record<string, unknown> {
+  const sandbox: Record<string, unknown> = {
+    args,
+    budget,
+    console: {
+      log: (..._a: unknown[]) => {}, // no-op in sandbox
+      error: (..._a: unknown[]) => {},
+    },
+    // Primitives are injected by the runtime, not the sandbox
+  }
+
+  // Override Date to block now() and argless constructor
+  const OriginalDate = Date
+  sandbox.Date = new Proxy(OriginalDate, {
+    construct(_target, constructorArgs) {
+      if (constructorArgs.length === 0) {
+        throw new Error('new Date() is disabled in workflow sandbox. Pass timestamps via args.')
+      }
+      return new (OriginalDate as unknown as new (...a: unknown[]) => Date)(
+        ...(constructorArgs as [number]),
+      )
+    },
+    get(_target, prop) {
+      if (prop === 'now') {
+        throw new Error('Date.now() is disabled in workflow sandbox. Pass timestamps via args.')
+      }
+      const val = (OriginalDate as unknown as Record<string, unknown>)[prop as string]
+      return typeof val === 'function' ? (val as Function).bind(OriginalDate) : val
+    },
+  })
+
+  // Override Math.random
+  sandbox.Math = new Proxy(Math, {
+    get(_target, prop) {
+      if (prop === 'random') {
+        throw new Error('Math.random() is disabled in workflow sandbox. Use a seed from args.')
+      }
+      const val = (Math as unknown as Record<string, unknown>)[prop as string]
+      return typeof val === 'function' ? (val as Function).bind(Math) : val
+    },
+  })
+
+  // Block crypto.randomUUID
+  const globalCrypto = (globalThis as Record<string, unknown>).crypto as
+    | { randomUUID?: unknown; [key: string]: unknown }
+    | undefined
+  if (globalCrypto) {
+    sandbox.crypto = new Proxy(globalCrypto, {
+      get(_target, prop) {
+        if (prop === 'randomUUID') {
+          throw new Error('crypto.randomUUID() is disabled in workflow sandbox.')
+        }
+        const val = (globalCrypto as Record<string, unknown>)[prop as string]
+        return typeof val === 'function' ? (val as Function).bind(globalCrypto) : val
+      },
+    })
+  }
+
+  return sandbox
+}
+
+/** Check whether a given API identifier is in the forbidden set. */
+export function isForbidden(id: string): boolean {
+  return FORBIDDEN.has(id)
+}