@miphamai/cli 0.9.0 → 0.11.0

package/src/ui/commands.ts

@@ -392,18 +392,16 @@ const skillsCmd: CommandHandler = (ctx) => {
 // Workflow
 // ═══════════════════════════════════════════════════════════════
 
-const planCmd: CommandHandler = (_ctx) => ({
-  content: stripIndent`
-    ── Plan Mode ──
-    Plan mode activated — read-only analysis and design.
-    No code will be modified. Use /no-plan to exit.
-
-    In plan mode you can:
-    • Explore codebase and analyze architecture
-    • Design implementation approaches
-    • Create structured plans before coding
-  `,
-})
+const planCmd: CommandHandler = (_ctx, args) => {
+  const description = args.join(' ') || undefined
+  return {
+    content:
+      '── Plan Mode ──\n\nEntering plan mode — read-only analysis and design.\nUse EnterPlanMode to start, ExitPlanMode to submit for approval.',
+    forwardToAI: description
+      ? `Use EnterPlanMode with description: "${description}". Then explore, design, and use ExitPlanMode when ready for approval.`
+      : 'Use EnterPlanMode to enter plan mode. Explore the codebase, design an approach, then use ExitPlanMode to submit for approval.',
+  }
+}
 
 const tddCmd: CommandHandler = (_ctx, args) => {
   const target = args.join(' ') || 'the current task'
@@ -3184,64 +3182,183 @@ Full changelog: https://mipham.ai/code/releases`,
 // IDE — IDE integration guide
 // ═══════════════════════════════════════════════════════════════
 
-const ideCmd: CommandHandler = () => ({
-  content: `── IDE Integration ──
-
-VS Code:
-  Install the Mipham Code extension from the VS Code marketplace.
-  • Open Command Palette (Cmd+Shift+P)
-  • Search "Mipham Code: Start"
-  • The terminal panel opens with Mipham Code loaded
+const ideCmd: CommandHandler = async (_ctx) => {
+  const { mkdirSync, writeFileSync, existsSync } = await import('node:fs')
+  const { join } = await import('node:path')
 
-  Or manually: add to .vscode/settings.json
-  {
-    "terminal.integrated.profiles.osx": {
-      "mipham": { "path": "bun", "args": ["run", "mipham"] }
-    }
-  }
+  const cwd = process.cwd()
+  const vscodeDir = join(cwd, '.vscode')
+  mkdirSync(vscodeDir, { recursive: true })
 
-JetBrains (IntelliJ / WebStorm / PyCharm):
-  • Settings → Tools → Terminal → Shell path
-  • Set to: bun run ~/path/to/mipham-code/apps/cli/bin/mipham
+  const files: string[] = []
 
-Terminal (any):
-  alias mipham='cd your-project && bun run path/to/mipham'
+  // ── Detect bun path ──
+  let bunPath = '/opt/homebrew/bin/bun'
+  try {
+    const { execSync } = await import('node:child_process')
+    const detected = execSync('which bun 2>/dev/null || echo /opt/homebrew/bin/bun', {
+      encoding: 'utf-8',
+    }).trim()
+    if (detected) bunPath = detected
+  } catch {
+    // Use default
+  }
+
+  // ── settings.json: terminal profile ──
+  const settingsPath = join(vscodeDir, 'settings.json')
+  const settings = {
+    'terminal.integrated.profiles.osx': {
+      mipham: {
+        path: bunPath,
+        args: ['run', 'mipham'],
+        cwd: '${workspaceFolder}',
+      },
+    },
+  }
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8')
+  files.push('.vscode/settings.json')
+
+  // ── keybindings.json: Cmd+Esc launch ──
+  const keybindingsPath = join(vscodeDir, 'keybindings.json')
+  const keybindings = [
+    {
+      key: 'cmd+escape',
+      command: 'workbench.action.terminal.focus',
+      when: 'terminalProcessSupported',
+    },
+    {
+      key: 'cmd+shift+m',
+      command: 'workbench.action.terminal.new',
+    },
+  ]
+  writeFileSync(keybindingsPath, JSON.stringify(keybindings, null, 2) + '\n', 'utf-8')
+  files.push('.vscode/keybindings.json')
 
-Or install globally: ${NPM_INSTALL_COMMAND}
+  // ── extensions.json: recommended ──
+  const extensionsPath = join(vscodeDir, 'extensions.json')
+  const extensions = {
+    recommendations: ['miphamai.mipham-code'],
+  }
+  writeFileSync(extensionsPath, JSON.stringify(extensions, null, 2) + '\n', 'utf-8')
+  files.push('.vscode/extensions.json')
 
-Coming soon: dedicated VS Code & JetBrains plugin extensions.`,
-})
+  return {
+    content: [
+      '── VS Code Integration ──',
+      '',
+      `Generated in ${vscodeDir}:`,
+      ...files.map((f) => `  ✅ ${f}`),
+      '',
+      'What was configured:',
+      '  • Terminal profile "mipham" — opens Mipham Code in integrated terminal',
+      '  • Keyboard shortcut Cmd+Esc — focus terminal',
+      '  • Cmd+Shift+M — new terminal',
+      '',
+      'To use:',
+      '  1. Restart VS Code (or reload window: Cmd+Shift+P → Reload Window)',
+      '  2. Open terminal: Ctrl+` or Cmd+Esc',
+      '  3. Select "mipham" profile from the terminal dropdown',
+      '',
+      'Install the VS Code extension for full integration:',
+      `  code --install-extension miphamai.mipham-code`,
+      '',
+      'JetBrains: Settings → Tools → Terminal → Shell path → bun run mipham',
+    ].join('\n'),
+  }
+}
 
 // ═══════════════════════════════════════════════════════════════
 // Terminal Setup — shell integration guide
 // ═══════════════════════════════════════════════════════════════
 
-const terminalSetupCmd: CommandHandler = () => ({
-  content: `── Terminal Setup ──
-
-Install globally:
-  ${NPM_INSTALL_COMMAND}
-  mipham
-
-One-liner install:
-  curl -fsSL https://mipham.ai/install.sh | bash
+const terminalSetupCmd: CommandHandler = async () => {
+  const { writeFileSync, appendFileSync, existsSync, mkdirSync } = await import('node:fs')
+  const { join } = await import('node:path')
+  const { homedir } = await import('node:os')
 
-Add to shell profile (~/.zshrc or ~/.bashrc):
-  alias mipham='bun run ~/path/to/mipham-code/apps/cli/bin/mipham'
+  const home = homedir()
+  const lines: string[] = ['── Terminal Setup ──', '']
+
+  // ── 1. Generate standalone shell setup script ──
+  const miphamDir = join(home, '.mipham')
+  mkdirSync(miphamDir, { recursive: true })
+
+  const shellScript = join(miphamDir, 'shell-setup.sh')
+  const shellContent = [
+    '#!/bin/bash',
+    '# Mipham Code — Shell Integration',
+    '# Source this file in your shell profile:',
+    '#   source ~/.mipham/shell-setup.sh',
+    '',
+    `export MIPHAM_HOME="${home}/.mipham"`,
+    '',
+    '# Alias: launch Mipham Code in current directory',
+    `alias mipham='cd $(pwd) && ${NPM_INSTALL_COMMAND} > /dev/null 2>&1; mipham'`,
+    '',
+    '# Or use the local development version:',
+    '# alias mipham="bun run /path/to/mipham-code/apps/cli/bin/mipham"',
+    '',
+    '# Auto-detect provider from config',
+    'if [ -f ~/.mipham/config.yml ]; then',
+    '  export MIPHAM_PROVIDER=$(grep "defaultProvider:" ~/.mipham/config.yml | awk "{print \$2}")',
+    'fi',
+  ].join('\n')
+  writeFileSync(shellScript, shellContent + '\n', 'utf-8')
+  lines.push(`  ✅ Generated: ${shellScript}`)
+
+  // ── 2. Append to shell profile ──
+  const shell = process.env.SHELL || '/bin/zsh'
+  const profileName = shell.includes('zsh') ? '.zshrc' : '.bashrc'
+  const profilePath = join(home, profileName)
+  const sourceLine = `\n# Mipham Code shell integration\n[ -f ~/.mipham/shell-setup.sh ] && source ~/.mipham/shell-setup.sh\n`
 
-  # Or with a specific provider/model:
-  alias mipham='mipham --provider anthropic --model claude-opus-4-8'
+  try {
+    const existing = existsSync(profilePath)
+      ? require('node:fs').readFileSync(profilePath, 'utf-8')
+      : ''
+    if (existing.includes('shell-setup.sh')) {
+      lines.push(`  ⏭  ${profileName} already has Mipham Code integration`)
+    } else {
+      appendFileSync(profilePath, sourceLine, 'utf-8')
+      lines.push(`  ✅ Added to ~/${profileName}`)
+    }
+  } catch {
+    lines.push(`  ⚠️  Could not update ~/${profileName}. Add manually:`)
+    lines.push(`     echo '${sourceLine.trim()}' >> ~/${profileName}`)
+  }
 
-Upgrade:
-  curl -fsSL https://mipham.ai/install.sh | bash
-  # or:   ${NPM_UPDATE_COMMAND}
+  // ── 3. Global install check ──
+  lines.push('')
+  lines.push('── Installation ──')
+  try {
+    const { execSync } = await import('node:child_process')
+    const miphamPath = execSync('which mipham 2>/dev/null || echo ""', { encoding: 'utf-8' }).trim()
+    if (miphamPath) {
+      lines.push(`  ✅ mipham found at: ${miphamPath}`)
+      const version = execSync('mipham --version 2>/dev/null || echo "unknown"', {
+        encoding: 'utf-8',
+      }).trim()
+      lines.push(`  📦 Version: ${version}`)
+    } else {
+      lines.push(`  ⚠️  mipham not in PATH. Install globally:`)
+      lines.push(`     ${NPM_INSTALL_COMMAND}`)
+      lines.push(`     or: curl -fsSL https://mipham.ai/install.sh | bash`)
+    }
+  } catch {
+    lines.push(`  💡 Install: ${NPM_INSTALL_COMMAND}`)
+  }
 
-Verify installation:
-  mipham --version
-  mipham --help
+  // ── 4. Verify ──
+  lines.push('')
+  lines.push('── Next Steps ──')
+  lines.push('  1. Restart your terminal or run: source ~/.mipham/shell-setup.sh')
+  lines.push('  2. Run: mipham --version')
+  lines.push('  3. Start coding: cd your-project && mipham')
+  lines.push('')
+  lines.push(`Works with: Zsh, Bash. Shell: ${shell}`)
 
-Works with: Bash, Zsh, Fish, PowerShell, Windows Terminal`,
-})
+  return { content: lines.join('\n') }
+}
 
 // ═══════════════════════════════════════════════════════════════
 // Phase 4 — MCP Server Management

package/src/workflow/primitives/agent.ts

@@ -1,6 +1,7 @@
 import { SubAgent } from '../../agent/sub-agent'
 import type { ProviderRegistry } from '../../providers/registry'
 import type { ToolDefinition } from '../../shared/index.ts'
+import { validateJSONSchema, formatValidationErrors } from '../schema-validator'
 
 export interface WorkflowAgentOpts {
   label?: string
@@ -9,11 +10,19 @@ export interface WorkflowAgentOpts {
   model?: string
   provider?: string
   effort?: 'low' | 'medium' | 'high' | 'max'
+  /** Maximum retries on schema validation failure (default: 2). */
+  maxRetries?: number
 }
 
 /**
  * Workflow agent() primitive — creates a SubAgent with optional
- * provider/model override and structured output schema.
+ * provider/model override and structured output schema validation.
+ *
+ * When `schema` is provided:
+ *   1. The sub-agent is prompted to return valid JSON matching the schema.
+ *   2. The result is JSON.parsed and validated against the schema.
+ *   3. On validation failure, the sub-agent is retried with error feedback.
+ *   4. Returns the validated object, or { raw, validationErrors } on final failure.
  */
 export async function workflowAgent(
   prompt: string,
@@ -28,24 +37,77 @@ export async function workflowAgent(
     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
-  })
+  const maxRetries = opts.maxRetries ?? 2
 
-  // If schema is provided, attempt to parse the result as JSON
+  // Build the prompt — if schema is requested, instruct the model to return JSON
+  let effectivePrompt = prompt
   if (opts.schema) {
+    const schemaDesc = JSON.stringify(opts.schema, null, 2)
+    effectivePrompt =
+      `${prompt}\n\n` +
+      `IMPORTANT: Your response MUST be valid JSON matching this schema:\n` +
+      `\`\`\`json\n${schemaDesc}\n\`\`\`\n` +
+      `Return ONLY the JSON object, no other text. Do not wrap in markdown code fences.`
+  }
+
+  const sub = new SubAgent(registry, toolRegistry)
+
+  // ── Attempt execution with optional schema validation + retry ──
+  let lastResult = ''
+  let lastErrors: string[] = []
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    const retryPrompt =
+      attempt === 0
+        ? effectivePrompt
+        : `${effectivePrompt}\n\n` +
+          `[RETRY #${attempt}] Your previous response did NOT match the required schema.\n` +
+          `Validation errors:\n${lastErrors.map((e) => `  • ${e}`).join('\n')}\n\n` +
+          `Please fix the errors and return a valid JSON object matching the schema exactly.`
+
+    const result = await sub.execute(retryPrompt, opts.label || 'workflow-agent', {
+      type: 'general',
+      modelOverride: opts.model,
+      allowedTools: undefined, // use all tools by default
+    })
+
+    lastResult = result
+
+    // No schema — return raw result
+    if (!opts.schema) {
+      return result
+    }
+
+    // Try to parse and validate
     try {
-      const parsed = JSON.parse(result)
-      // Basic validation: return parsed object
-      return parsed
-    } catch {
-      // Return raw text if JSON parse fails
-      return { raw: result }
+      // Extract JSON from potential markdown fences
+      let jsonStr = result.trim()
+      const fenceMatch = jsonStr.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/)
+      if (fenceMatch) {
+        jsonStr = fenceMatch[1]!.trim()
+      }
+
+      const parsed = JSON.parse(jsonStr)
+      const errors = validateJSONSchema(parsed, opts.schema as Record<string, unknown>)
+
+      if (errors.length === 0) {
+        // Valid! Return the parsed object
+        return parsed
+      }
+
+      // Not valid — collect errors for retry
+      lastErrors = [formatValidationErrors(errors)]
+    } catch (err) {
+      // JSON parse error
+      lastErrors = [`JSON parse error: ${String(err)}. Ensure your response is valid JSON only.`]
     }
   }
 
-  return result
+  // All retries exhausted — return raw result with validation errors
+  try {
+    const parsed = JSON.parse(lastResult)
+    return { raw: lastResult, parsed, validationErrors: lastErrors }
+  } catch {
+    return { raw: lastResult, validationErrors: lastErrors }
+  }
 }

package/src/workflow/runtime.ts

@@ -1,5 +1,5 @@
 import { createSandbox } from './sandbox'
-import { createJournal, appendJournal } from './journal'
+import { createJournal, appendJournal, loadJournal, loadScript } from './journal'
 import { createBudget } from './budget'
 import { workflowAgent } from './primitives/agent'
 import { parallel } from './primitives/parallel'
@@ -12,30 +12,103 @@ export interface WorkflowRunResult {
   runId: string
   result: unknown
   journalEntries: number
+  /** Number of agent() calls served from cache (only set when resumeFromRunId is used). */
+  cacheHits: number
+  /** Number of agent() calls executed live (only set when resumeFromRunId is used). */
+  cacheMisses: number
+}
+
+/**
+ * Generate a cache key for an agent() call.
+ * Uses prompt + deterministic subset of opts.
+ */
+function agentCacheKey(prompt: string, opts: Record<string, unknown> = {}): string {
+  const relevant = {
+    prompt,
+    label: opts.label,
+    phase: opts.phase,
+    model: opts.model,
+    provider: opts.provider,
+  }
+  return JSON.stringify(relevant)
 }
 
 /**
  * Execute a workflow script string.
  *
- * The script is evaluated in a sandboxed context with the workflow
- * primitives (agent, parallel, pipeline, phase, args, budget) injected.
+ * When `resumeFromRunId` is provided:
+ *   - Loads the journal from the prior run
+ *   - Compares the current script against the saved script
+ *   - Builds a cache from prior agent() results (keyed by prompt+opts)
+ *   - New agent() calls that match the cache return the cached result
+ *   - New/changed agent() calls execute live and append to the journal
+ *   - Returns cacheHits and cacheMisses counts
+ *
+ * The sandbox blocks non-deterministic APIs (Date.now, Math.random) to make
+ * this deterministic replay possible.
  */
 export async function runWorkflow(
   script: string,
   engine: QueryEngine,
   args: unknown = {},
   budgetTotal: number | null = null,
+  resumeFromRunId?: string,
 ): Promise<WorkflowRunResult> {
-  const runId = `run-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`
-  createJournal(runId, script)
+  let runId: string
+  let cacheHits = 0
+  let cacheMisses = 0
+
+  // ── Resume mode: load prior journal, build cache ──
+  let resultCache: Map<string, unknown> | null = null
+  if (resumeFromRunId) {
+    const savedScript = loadScript(resumeFromRunId)
+    if (savedScript && savedScript !== script) {
+      // Script changed — warn but proceed (cache may have stale entries)
+      process.stderr.write(
+        `[workflow] ⚠ Script differs from saved run "${resumeFromRunId}". ` +
+          `Cache may contain stale entries for changed agent calls.\n`,
+      )
+    }
+
+    const priorEntries = loadJournal(resumeFromRunId)
+    if (priorEntries.length === 0) {
+      process.stderr.write(
+        `[workflow] ⚠ No journal entries found for run "${resumeFromRunId}". Proceeding without cache.\n`,
+      )
+    } else {
+      resultCache = new Map()
+      for (const entry of priorEntries) {
+        if (entry.type === 'agent' && entry.prompt && entry.result !== undefined) {
+          const key = agentCacheKey(entry.prompt, entry.opts || {})
+          resultCache.set(key, entry.result)
+        }
+      }
+    }
+
+    // Re-use the existing run directory for appending
+    runId = resumeFromRunId
+  } else {
+    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
+  // Wrap primitives with journal recording + cache support
   const agent = async (prompt: string, opts?: Record<string, unknown>) => {
+    // Check cache first
+    if (resultCache) {
+      const key = agentCacheKey(prompt, opts || {})
+      if (resultCache.has(key)) {
+        cacheHits++
+        return resultCache.get(key)!
+      }
+    }
+    cacheMisses++
+
     const result = await workflowAgent(
       prompt,
       registry,
@@ -83,5 +156,9 @@ export async function runWorkflow(
 
   const result = await scriptFn(agent, parallel, pipeline, wrappedPhase, log, args, budget)
 
-  return { runId, result, journalEntries: 0 }
+  // Count journal entries from state
+  const priorEntries = loadJournal(runId)
+  const journalEntries = priorEntries.length
+
+  return { runId, result, journalEntries, cacheHits, cacheMisses }
 }

package/src/workflow/schema-validator.ts

@@ -0,0 +1,162 @@
+/**
+ * Lightweight JSON Schema validator for workflow agent() schema parameter.
+ *
+ * Supports:
+ *   - type: string | number | integer | boolean | object | array
+ *   - properties (objects), items (arrays), required, enum
+ *   - Nested objects and arrays (recursive validation)
+ *
+ * Zero external dependencies — pure TypeScript implementation.
+ */
+
+export interface ValidationError {
+  path: string // JSON path to the error, e.g. "$.name" or "$.items[0].value"
+  message: string
+}
+
+/**
+ * Validate `data` against a JSON Schema definition.
+ * Returns an array of ValidationError — empty means valid.
+ */
+export function validateJSONSchema(
+  data: unknown,
+  schema: Record<string, unknown>,
+): ValidationError[] {
+  const errors: ValidationError[] = []
+  _validate(data, schema, '$', errors)
+  return errors
+}
+
+/**
+ * Format validation errors into a human-readable message for LLM feedback.
+ */
+export function formatValidationErrors(errors: ValidationError[]): string {
+  if (errors.length === 0) return ''
+  return errors.map((e) => `  • ${e.path}: ${e.message}`).join('\n')
+}
+
+// ── Internal recursive validator ──
+
+function _validate(
+  data: unknown,
+  schema: Record<string, unknown>,
+  path: string,
+  errors: ValidationError[],
+): void {
+  const type = schema.type as string | undefined
+
+  // ── Null check ──
+  if (data === null || data === undefined) {
+    // If required, the parent object handles this. Here we just check type mismatch.
+    if (type && type !== 'null') {
+      errors.push({ path, message: `expected ${type}, got null` })
+    }
+    return
+  }
+
+  // ── Type checking ──
+  if (type) {
+    const actualType = Array.isArray(data) ? 'array' : typeof data
+    const expectedType = type === 'integer' ? 'number' : type
+
+    if (expectedType === 'number' && actualType === 'number') {
+      // OK — integer is a subset of number
+    } else if (expectedType !== actualType) {
+      errors.push({ path, message: `expected type "${type}", got "${actualType}"` })
+      return // Can't validate further if type is wrong
+    }
+
+    // Integer check
+    if (type === 'integer' && !Number.isInteger(data)) {
+      errors.push({ path, message: `expected integer, got ${data}` })
+    }
+  }
+
+  // ── Enum validation ──
+  if (schema.enum && Array.isArray(schema.enum)) {
+    if (!schema.enum.includes(data)) {
+      errors.push({
+        path,
+        message: `value must be one of: ${schema.enum.map((v) => JSON.stringify(v)).join(', ')}`,
+      })
+    }
+  }
+
+  // ── Object validation ──
+  if (type === 'object' || (!type && typeof data === 'object' && !Array.isArray(data))) {
+    const obj = data as Record<string, unknown>
+    const properties = schema.properties as Record<string, Record<string, unknown>> | undefined
+    const required = schema.required as string[] | undefined
+
+    // Required fields
+    if (required) {
+      for (const field of required) {
+        if (obj[field] === undefined || obj[field] === null) {
+          errors.push({ path: `${path}.${field}`, message: `required field is missing` })
+        }
+      }
+    }
+
+    // Property validation
+    if (properties) {
+      for (const [key, propSchema] of Object.entries(properties)) {
+        const value = obj[key]
+        if (value !== undefined && value !== null) {
+          _validate(value, propSchema, `${path}.${key}`, errors)
+        }
+      }
+    }
+  }
+
+  // ── Array validation ──
+  if (type === 'array' || (!type && Array.isArray(data))) {
+    const arr = data as unknown[]
+    const items = schema.items as Record<string, unknown> | undefined
+
+    if (items) {
+      for (let i = 0; i < arr.length; i++) {
+        _validate(arr[i], items, `${path}[${i}]`, errors)
+      }
+    }
+
+    // minItems / maxItems
+    if (schema.minItems !== undefined && arr.length < (schema.minItems as number)) {
+      errors.push({
+        path,
+        message: `array has ${arr.length} items, minimum is ${schema.minItems}`,
+      })
+    }
+    if (schema.maxItems !== undefined && arr.length > (schema.maxItems as number)) {
+      errors.push({
+        path,
+        message: `array has ${arr.length} items, maximum is ${schema.maxItems}`,
+      })
+    }
+  }
+
+  // ── String validation ──
+  if ((type === 'string' || typeof data === 'string') && typeof data === 'string') {
+    if (schema.minLength !== undefined && data.length < (schema.minLength as number)) {
+      errors.push({
+        path,
+        message: `string length ${data.length} is less than minimum ${schema.minLength}`,
+      })
+    }
+    if (schema.maxLength !== undefined && data.length > (schema.maxLength as number)) {
+      errors.push({
+        path,
+        message: `string length ${data.length} exceeds maximum ${schema.maxLength}`,
+      })
+    }
+  }
+
+  // ── Number validation ──
+  if ((type === 'number' || type === 'integer') && typeof data === 'number') {
+    if (schema.minimum !== undefined && data < (schema.minimum as number)) {
+      errors.push({ path, message: `value ${data} is less than minimum ${schema.minimum}` })
+    }
+    if (schema.maximum !== undefined && data > (schema.maximum as number)) {
+      errors.push({ path, message: `value ${data} exceeds maximum ${schema.maximum}` })
+    }
+  }
+}