@miphamai/cli 0.26.0 → 0.28.0

package/src/tools/agent/exit-plan.ts

@@ -1,53 +1,62 @@
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
 import type { ToolDefinition } from '../../shared/index.ts'
 
 export const exitPlanModeTool: ToolDefinition = {
   name: 'ExitPlanMode',
   description:
-    'Exit plan mode and submit your plan for approval. ' +
-    'Set approved: true to switch to acceptEdits mode (code changes allowed). ' +
-    'Set approved: false to revert to default mode. ' +
-    'Use this after you have finished designing your approach in plan mode.',
+    'Exit plan mode and present your plan for user approval. ' +
+    'This tool does NOT switch to implementation mode — the user must explicitly approve first. ' +
+    'After calling this, present your plan and ask the user to confirm. ' +
+    'The user can approve by saying "approved" or "/approve", or by cycling to acceptEdits mode with Shift+Tab.',
   category: 'agent',
   permission: 'auto',
   parameters: {
     type: 'object',
     properties: {
-      approved: {
-        type: 'boolean',
+      planFile: {
+        type: 'string',
         description:
-          'Whether the user approved the plan. true → switch to acceptEdits mode. false → revert to default.',
+          'Path to the plan file you wrote (e.g., .mipham/plans/plan-2026-08-10T12-00-00.md). If omitted, the most recent plan file is used.',
       },
     },
-    required: ['approved'],
+    required: [],
   },
-  async execute(params, _ctx) {
-    const approved = params.approved === true
+  async execute(params, ctx) {
+    const planDir = join(ctx.cwd, '.mipham', 'plans')
+    const planFile = (params.planFile as string) || ''
 
-    if (approved) {
-      return {
-        success: true,
-        content: [
-          '── Plan Approved ──',
-          '',
-          '✓ Exiting plan mode.',
-          '✓ Switching to acceptEdits mode — reads and file edits are auto-approved.',
-          '',
-          'You can now implement the plan. The plan file is in .mipham/plans/.',
-          '',
-          'Use Shift+Tab to cycle permission modes if you need to change.',
-        ].join('\n'),
+    // Try to read the plan to confirm it exists
+    let planContent = ''
+    try {
+      const planPath = planFile || ''
+      if (planPath) {
+        planContent = readFileSync(planPath, 'utf-8')
       }
+    } catch {
+      // Plan file not found — still exit plan mode
     }
 
     return {
       success: true,
       content: [
-        '── Plan Mode Exited ──',
+        '── Plan Ready for Review ──',
         '',
-        '✓ Returning to default permission mode.',
+        '✓ Exiting plan mode.',
+        '✓ Plan file saved. Present your plan to the user now.',
         '',
-        'No code changes were made. The plan file is preserved in .mipham/plans/.',
-        'Use EnterPlanMode again when ready to resume planning.',
+        '⚠️  IMPORTANT: You are still in limited permission mode.',
+        '    The user must explicitly approve before you can make changes.',
+        '',
+        'Next steps:',
+        '  1. Present your plan to the user (summarize key decisions)',
+        '  2. Ask: "Does this plan look good? Reply approved to begin."',
+        '  3. Wait for the user to explicitly say "approved" or "/approve"',
+        '  4. Only then switch to acceptEdits mode (Shift+Tab or user action)',
+        '',
+        'DO NOT start implementing until the user explicitly approves.',
+        'DO NOT call ExitPlanMode with approved:true — that parameter no longer exists.',
+        planContent ? `\n── Plan Content (for reference) ──\n\n${planContent.slice(0, 3000)}` : '',
       ].join('\n'),
     }
   },

package/src/tools/exec/bash.ts

@@ -185,6 +185,105 @@ export function detectViolations(stderr: string): string[] {
   return violations
 }
 
+/**
+ * Vibe coding: Parse stderr output for error locations (file path + line + column).
+ * Supports common tool formats: TypeScript, ESLint, pytest, Rust, Go, Prettier, etc.
+ * Returns up to 10 unique locations sorted by file then line.
+ */
+interface ErrorLocation {
+  file: string
+  line: number
+  col?: number
+  message?: string
+}
+
+function parseErrorLocations(stderr: string): ErrorLocation[] {
+  const locations: ErrorLocation[] = []
+
+  // TypeScript / ESLint / Prettier: path(line,col): message
+  // e.g., src/foo.ts(42,10): error TS2304: Cannot find name 'foo'
+  const tsPattern = /([^\s(]+)\((\d+),(\d+)\):\s*(.+)/g
+  let match: RegExpExecArray | null
+  let m: RegExpExecArray | null
+  while ((m = tsPattern.exec(stderr)) !== null) {
+    locations.push({
+      file: m[1]!,
+      line: parseInt(m[2]!),
+      col: parseInt(m[3]!),
+      message: (m[4] || '').slice(0, 120),
+    })
+  }
+
+  // pytest / Python: path:line: message
+  // e.g., tests/test_foo.py:42: AssertionError: ...
+  const pyPattern = /([^\s:]+\.py):(\d+):\s*(.+)/g
+  while ((match = pyPattern.exec(stderr)) !== null) {
+    const pm = match
+    locations.push({
+      file: pm[1]!,
+      line: parseInt(pm[2]!),
+      message: (pm[3] || '').slice(0, 120),
+    })
+  }
+
+  // Rust: --> path:line:col
+  // e.g., --> src/main.rs:42:10
+  const rustPattern = /-->\s*([^\s:]+):(\d+):(\d+)/g
+  while ((match = rustPattern.exec(stderr)) !== null) {
+    const rm = match
+    locations.push({
+      file: rm[1]!,
+      line: parseInt(rm[2]!),
+      col: parseInt(rm[3]!),
+    })
+  }
+
+  // Go: path:line:col: message
+  // e.g., ./main.go:42:10: undefined: foo
+  const goPattern = /([^\s:]+\.go):(\d+):(\d+):\s*(.+)/g
+  while ((match = goPattern.exec(stderr)) !== null) {
+    const gm2 = match
+    locations.push({
+      file: gm2[1]!,
+      line: parseInt(gm2[2]!),
+      col: parseInt(gm2[3]!),
+      message: (gm2[4] || '').slice(0, 120),
+    })
+  }
+
+  // Generic: path:line (any file extension)
+  // e.g., src/foo.ts:42
+  const genericPattern = /([^\s:]+\.[a-zA-Z]{1,6}):(\d+)\b/g
+  while ((match = genericPattern.exec(stderr)) !== null) {
+    const gm = match
+    const file = gm[1]!
+    // Skip if we already have this exact location from a more specific pattern
+    const alreadyHave = locations.some((l) => l.file === file && l.line === parseInt(gm[2]!))
+    if (!alreadyHave) {
+      locations.push({ file, line: parseInt(match[2]!) })
+    }
+  }
+
+  // Deduplicate and sort: same file+line → keep first
+  const seen = new Set<string>()
+  const unique: ErrorLocation[] = []
+  for (const loc of locations) {
+    const key = `${loc.file}:${loc.line}`
+    if (!seen.has(key)) {
+      seen.add(key)
+      unique.push(loc)
+    }
+  }
+
+  // Sort by file path then line number
+  unique.sort((a, b) => {
+    const fileCmp = a.file.localeCompare(b.file)
+    return fileCmp !== 0 ? fileCmp : a.line - b.line
+  })
+
+  return unique.slice(0, 10)
+}
+
 export const bashTool: ToolDefinition = {
   name: 'Bash',
   description:
@@ -283,6 +382,20 @@ export const bashTool: ToolDefinition = {
         if (violations.length > 0) {
           errorContent += '\n\n── Sandbox Violations ──\n' + violations.join('\n')
         }
+        // Vibe coding fix: auto-parse error locations from stderr
+        const errorLocations = parseErrorLocations(rawStderr)
+        if (errorLocations.length > 0) {
+          errorContent +=
+            '\n\n── Error Locations (for quick fix) ──\n' +
+            errorLocations
+              .map(
+                (l) =>
+                  `  ${l.file}:${l.line}` +
+                  (l.col ? `:${l.col}` : '') +
+                  (l.message ? ` — ${l.message}` : ''),
+              )
+              .join('\n')
+        }
         return {
           success: false,
           content: errorContent,

package/src/ui/input.tsx

@@ -83,6 +83,16 @@ export function InputBar({
   const [completionVerb, setCompletionVerb] = useState<string | null>(null)
   const prevLoading = useRef(isLoading)
 
+  // ── Message history for arrow-key navigation (Claude Code parity) ──
+  const [submittedHistory, setSubmittedHistory] = useState<string[]>([])
+  const historyIndexRef = useRef(-1) // -1 = not browsing history
+  const savedDraftRef = useRef('') // saved user draft before browsing history
+
+  // Stabilize t ref — prevents stale closures in intervals and avoids
+  // unnecessary effect re-runs when the i18n context value object changes.
+  const tRef = useRef(t)
+  tRef.current = t
+
   // ── Slash command hints ──
   const allCommands = useMemo(() => getCommandList(), [])
   const slashHints = useMemo(() => {
@@ -92,32 +102,33 @@ export function InputBar({
     return allCommands.filter((c) => c.name.toLowerCase().includes(filter)).slice(0, 8)
   }, [value, allCommands])
 
-  // Rotate gerunds while loading
+  // Rotate gerunds while loading — use tRef to avoid re-running when i18n context re-renders
   useEffect(() => {
     if (!isLoading) return
     const interval = setInterval(() => {
-      setVerb(t(pick(LOADING_KEYS)))
-    }, 1200)
+      setVerb(tRef.current(pick(LOADING_KEYS)))
+    }, 2000)
     return () => clearInterval(interval)
-  }, [isLoading, t])
+  }, [isLoading])
 
   // Pick a fresh gerund when loading starts
   useEffect(() => {
     if (isLoading) {
-      setVerb(t(pick(LOADING_KEYS)))
+      setVerb(tRef.current(pick(LOADING_KEYS)))
       setCompletionVerb(null)
     }
-  }, [isLoading, t])
+  }, [isLoading])
 
   // Flash a past participle when loading stops
   useEffect(() => {
     if (prevLoading.current === true && isLoading === false) {
-      setCompletionVerb(t(pick(COMPLETED_KEYS)))
+      setCompletionVerb(tRef.current(pick(COMPLETED_KEYS)))
       const timer = setTimeout(() => setCompletionVerb(null), 1500)
+      prevLoading.current = isLoading
       return () => clearTimeout(timer)
     }
     prevLoading.current = isLoading
-  }, [isLoading, t])
+  }, [isLoading])
 
   const [vimMode, setVimMode] = useState<VimMode>('insert')
   // NOTE: Dual mode state — React state (vimMode) drives UI re-renders (prompt color,
@@ -195,6 +206,39 @@ export function InputBar({
       return
     }
 
+    // ── Arrow-key history navigation (insert mode only, Claude Code parity) ──
+    if (vimEngine.current.mode === 'insert' && !searchMode) {
+      if (key.upArrow || key.downArrow) {
+        // Ignore if picker is active (command picker handles its own arrows)
+        if (value.startsWith('/')) return
+
+        if (key.upArrow) {
+          if (submittedHistory.length === 0) return
+          // Save current draft the first time we enter history browsing
+          if (historyIndexRef.current === -1) {
+            savedDraftRef.current = value
+          }
+          const newIndex = Math.min(historyIndexRef.current + 1, submittedHistory.length - 1)
+          historyIndexRef.current = newIndex
+          setValue(submittedHistory[submittedHistory.length - 1 - newIndex]!)
+          return
+        }
+        if (key.downArrow) {
+          if (historyIndexRef.current === -1) return
+          const newIndex = historyIndexRef.current - 1
+          historyIndexRef.current = newIndex
+          if (newIndex === -1) {
+            // Back to the original draft
+            setValue(savedDraftRef.current)
+            savedDraftRef.current = ''
+          } else {
+            setValue(submittedHistory[submittedHistory.length - 1 - newIndex]!)
+          }
+          return
+        }
+      }
+    }
+
     if (vimEngine.current.mode !== 'normal') return
 
     // Handle search mode — collect query characters
@@ -288,6 +332,10 @@ export function InputBar({
 
   const handleSubmit = (val: string) => {
     if (!val.trim() || isLoading) return
+    // Save to message history for arrow-key navigation
+    setSubmittedHistory((prev) => [...prev, val])
+    historyIndexRef.current = -1
+    savedDraftRef.current = ''
     onSubmit(val)
     setValue('')
     setPickerActive(false)
@@ -327,6 +375,11 @@ export function InputBar({
           onChange={(val) => {
             // Block text changes during search mode — keys go to search query
             if (searchMode) return
+            // Reset history browsing when user starts typing
+            if (historyIndexRef.current !== -1) {
+              historyIndexRef.current = -1
+              savedDraftRef.current = ''
+            }
             setValue(val)
           }}
           onSubmit={handleSubmit}