@miphamai/cli 0.7.7 → 0.7.9

package/package.json

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

package/src/ui/app.tsx

@@ -175,12 +175,12 @@ export function App({
           return
         }
 
-        let injectMessage: string | undefined
+        let forwardToAI: string | undefined
 
         const handler = getCommand(command)
         if (handler) {
           const result = await handler(mkCtx(), args)
-          injectMessage = result.injectMessage
+          forwardToAI = result.forwardToAI
           setMessages((prev) => [
             ...prev,
             { role: 'user', content: input },
@@ -206,12 +206,12 @@ export function App({
           }
         }
 
-        // Bridge: if command set injectMessage, route to AI processing
-        if (injectMessage) {
-          input = injectMessage
+        // Bridge: if command set forwardToAI, route the message to AI processing
+        if (forwardToAI) {
+          input = forwardToAI
           // fall through to normal AI processing below
         } else {
-          // Unknown slash command or handler returned: proceed to normal AI processing
+          // No handler matched or handler didn't request AI routing — stop here
           return
         }
       }

package/src/ui/commands.ts

@@ -40,8 +40,9 @@ export interface CommandResult {
   clearMessages?: boolean
   /** Content to copy to clipboard (handled by caller) */
   copyContent?: string
-  /** If set, inject this as a user message and route to AI processing (bridges slash commands → skills) */
-  injectMessage?: string
+  /** If set, route this message to the AI engine — bridges slash commands → skill/agent invocation.
+   *  The app layer replaces the user input with this string and falls through to AI processing. */
+  forwardToAI?: string
 }
 
 type CommandHandler = (
@@ -121,8 +122,8 @@ const helpCmd: CommandHandler = (ctx) => {
       ── Workflow ────────────────────────
       /plan          Enter plan mode (read-only)
       /no-plan       Exit plan mode
-      /tdd           TDD mode              [stub]
-      /todos         Task management
+      /tdd [goal]    Test-Driven Development workflow
+      /todos [list|create] Task management
       /tasks         Background tasks
       /review        Code review workflow
       /pr-comments   PR review summary
@@ -132,7 +133,7 @@ const helpCmd: CommandHandler = (ctx) => {
       /loop init      Scaffold .mipham/ vault structure
       /batch          Apply changes across files
       /hooks          Manage lifecycle hook scripts
-      /schedule      View scheduled tasks   [stub]
+      /schedule      View scheduled tasks
 
       ── Git & GitHub ─────────────────────
       /commit        Review staged changes + commit
@@ -401,25 +402,71 @@ const planCmd: CommandHandler = (_ctx) => ({
   `,
 })
 
-const tddCmd: CommandHandler = (_ctx) => ({
-  content: stripIndent`
-    ── TDD Mode ──  [stub]
-    Test-Driven Development workflow: RED → GREEN → REFACTOR.
-    Full TDD integration coming in a future release.
-  `,
-})
+const tddCmd: CommandHandler = (_ctx, args) => {
+  const target = args.join(' ') || 'the current task'
+  return {
+    content: stripIndent`
+      ── TDD Mode ──
+      Starting Test-Driven Development workflow for: ${target}
 
-const todosCmd: CommandHandler = (_ctx) => ({
-  content: stripIndent`
-    ── Task Management ──
-    Use the Task tool for structured task tracking:
-    • Create: Task tool with action=create
-    • List:   Task tool with action=list
-    • Update: Task tool with action=update
+      Cycle: 🔴 RED → 🟢 GREEN → 🔵 REFACTOR
+        RED:   Write a failing test first
+        GREEN: Write minimal code to pass
+        REFACTOR: Clean up while keeping tests green
 
-    Full /todos integration coming in a future release.
-  `,
-})
+      The AI will guide you through each cycle.
+    `,
+    forwardToAI: `Follow the Test-Driven Development workflow for ${target}:
+1. RED — Write a failing test that defines the expected behavior. Use the project's test framework (Vitest/Jest/pytest). Show me the test code and confirm it fails.
+2. GREEN — Write the minimum code needed to make the test pass. Run the test to verify it passes.
+3. REFACTOR — Clean up both test and implementation code. Remove duplication, improve names, simplify. Keep tests green.
+Repeat for each behavior. Do NOT write implementation before tests.`,
+  }
+}
+
+const todosCmd: CommandHandler = (_ctx, args) => {
+  const sub = args[0]
+  if (sub === 'create') {
+    const title = args.slice(1).join(' ')
+    if (!title.trim()) {
+      return {
+        content:
+          'Usage: /todos create <task-title>\n\nExample: /todos create Add user authentication',
+      }
+    }
+    return {
+      content: `── Create Task ──\n\nCreating task: "${title.trim()}"\n\nPassing to AI for structured task creation with TaskCreate...`,
+      forwardToAI: `Create a new task using TaskCreate with subject "${title.trim()}". Set a clear description and activeForm.`,
+    }
+  }
+
+  if (sub === 'list' || !sub) {
+    return {
+      content: stripIndent`
+        ── Task Management ──
+        Fetching current task list...
+
+        Shortcuts:
+          /todos list           Show all tasks
+          /todos create <title> Create a new task
+      `,
+      forwardToAI:
+        'Use TaskList to show all current tasks. Present them in a clear summary grouped by status (pending/in_progress/completed). If there are no tasks, suggest creating one.',
+    }
+  }
+
+  return {
+    content: stripIndent`
+      ── Task Management ──
+      /todos list           Show all tasks
+      /todos create <title> Create a new task
+
+      The AI manages task state via TaskCreate, TaskList, TaskUpdate, and TaskGet tools.
+      Tasks appear in the /tasks view and persist across the session.
+    `,
+    forwardToAI: 'Use TaskList to show all current tasks, then present them clearly.',
+  }
+}
 
 // ═══════════════════════════════════════════════════════════════
 // Project
@@ -1196,7 +1243,7 @@ const loopCmd: CommandHandler = async (_ctx, args) => {
 
   return {
     content: `── Loop Started ──\n\nInterval: ${interval} (${seconds}s)\nPrompt:   "${prompt}"\n\nScheduling via ScheduleWakeup — the prompt will re-schedule itself each cycle.\nUse /schedule to view active loops.`,
-    injectMessage: `use ScheduleWakeup to set up a recurring loop. delaySeconds=${seconds}, prompt: "${prompt}". Include at the end of the prompt: "Then call ScheduleWakeup again with delaySeconds=${seconds} and the same prompt to continue the loop."`,
+    forwardToAI: `use ScheduleWakeup to set up a recurring loop. delaySeconds=${seconds}, prompt: "${prompt}". Include at the end of the prompt: "Then call ScheduleWakeup again with delaySeconds=${seconds} and the same prompt to continue the loop."`,
   }
 }
 
@@ -1204,16 +1251,17 @@ const scheduleCmd: CommandHandler = (_ctx) => ({
   content: stripIndent`
     ── Scheduled Tasks ──
 
+    Fetching active scheduled tasks and loops...
+
     Active loops are managed via ScheduleWakeup (in-session) and
     CronCreate (durable, survives restarts).
 
     Use /loop <interval> <prompt> to start a recurring task.
     Use CronList to view all scheduled jobs.
     Use CronDelete <id> to cancel a durable job.
-
-    The ScheduleWakeup mechanism automatically re-schedules on
-    each wake, creating a self-perpetuating loop within the session.
   `,
+  forwardToAI:
+    'Use CronList to show all currently scheduled cron jobs (both durable and session-only). Present them in a clear table with: name/ID, schedule (cron expression), type (recurring vs one-shot), and status. Also note any active ScheduleWakeup loops if visible in the current session. If no scheduled tasks exist, suggest: "No scheduled tasks. Use /loop <interval> <prompt> to create a recurring task."',
 })
 
 // ═══════════════════════════════════════════════════════════════
@@ -1430,82 +1478,71 @@ const issueCmd: CommandHandler = async () => {
   }
 }
 
-// ═══════════════════════════════════════════════════════════════
-// Code Quality Commands (Claude Code parity)
-// ═══════════════════════════════════════════════════════════════
-
 // ═══════════════════════════════════════════════════════════════
 // Code Quality — bridge slash commands to skills (Claude Code parity)
 // ═══════════════════════════════════════════════════════════════
 
-const codeReviewCmd: CommandHandler = async () => {
-  try {
-    const { execSync } = await import('node:child_process')
-    const diff = execSync('git diff --stat', { encoding: 'utf-8', timeout: 5000 }).trim()
-    if (!diff) {
-      return {
-        content:
-          '─ Code Review ─\n\nNo uncommitted changes to review.\n\nTo review a specific file: /code-review path/to/file.ts',
+/** Factory for git-diff-based commands that bridge to AI skills via forwardToAI. */
+function gitDiffBridgeCmd(opts: {
+  label: string
+  noChangesHint: string
+  runningMsg: string
+  forwardToAI: string
+}): CommandHandler {
+  return async () => {
+    try {
+      const { execSync } = await import('node:child_process')
+      const diff = execSync('git diff --stat', { encoding: 'utf-8', timeout: 5000 }).trim()
+      if (!diff) {
+        return { content: `─ ${opts.label} ─\n\n${opts.noChangesHint}` }
       }
-    }
-    return {
-      content:
-        '─ Code Review ─\n\nReviewing uncommitted changes with the code-review skill (7 dimensions: correctness, security, performance, code quality, architecture, testing, language-specific)...',
-      injectMessage:
-        'use the code-review skill to review all uncommitted changes. Check all 7 dimensions: correctness, security, performance, code quality, architecture & design, testing, and language-specific issues.',
-    }
-  } catch {
-    return { content: '─ Code Review ─\n\nCould not detect changes. Are you in a git repository?' }
-  }
-}
-
-const simplifyCmd: CommandHandler = async () => {
-  try {
-    const { execSync } = await import('node:child_process')
-    const diff = execSync('git diff --stat', { encoding: 'utf-8', timeout: 5000 }).trim()
-    if (!diff) {
       return {
-        content:
-          '─ Simplify ─\n\nNo uncommitted changes to simplify.\n\nMake changes first, then run /simplify for cleanup review.',
+        content: `─ ${opts.label} ─\n\n${opts.runningMsg}\n\nChanged files:\n${diff}`,
+        forwardToAI: opts.forwardToAI,
       }
-    }
-    return {
-      content:
-        '─ Simplify ─\n\nRunning cleanup review — 4 passes: reuse, simplification, efficiency, abstraction level...',
-      injectMessage:
-        'use the self-review skill to review these uncommitted changes. Focus on 4 cleanup passes: 1) Reuse — find duplicated logic, replace with existing helpers; 2) Simplification — flatten nesting, remove redundant state and dead code; 3) Efficiency — fix repeated object creation, unnecessary I/O, memory issues; 4) Abstraction Level — ensure code sits at the right architectural layer. Apply equivalent transformations only — do NOT change logic or fix bugs.',
-    }
-  } catch {
-    return { content: '─ Simplify ─\n\nCould not detect changes. Are you in a git repository?' }
-  }
-}
-
-const verifyCmd: CommandHandler = async () => {
-  try {
-    const { execSync } = await import('node:child_process')
-    const diff = execSync('git diff --stat', { encoding: 'utf-8', timeout: 5000 }).trim()
-    if (!diff) {
+    } catch {
       return {
-        content:
-          '─ Verify ─\n\nNo uncommitted changes to verify.\n\nMake changes first, then run /verify for runtime verification.',
+        content: `─ ${opts.label} ─\n\nCould not detect changes. Are you in a git repository?`,
       }
     }
-    return {
-      content:
-        '─ Verify ─\n\nRunning runtime verification — observing actual execution behavior (not tests, not typecheck)...',
-      injectMessage:
-        'verify these uncommitted changes through runtime observation only. For each change: 1) Find the user-facing surface (CLI command, API endpoint, UI interaction); 2) Drive the changed code to execute; 3) Push boundaries — pass null, repeated values, wrong types, interrupt mid-flow (Ctrl-C), resize window; 4) Report verdict per change: PASS (works as expected), FAIL (does not work or breaks something), BLOCKED (cannot reach observable state), SKIP (no runtime surface, e.g. pure documentation). Do NOT run the test suite — observe real execution behavior only.',
-    }
-  } catch {
-    return { content: '─ Verify ─\n\nCould not detect changes. Are you in a git repository?' }
   }
 }
 
-const designCmd: CommandHandler = async (_ctx, args) => {
+const codeReviewCmd = gitDiffBridgeCmd({
+  label: 'Code Review',
+  noChangesHint:
+    'No uncommitted changes to review.\n\nTo review a specific file: /code-review path/to/file.ts',
+  runningMsg:
+    'Reviewing uncommitted changes with the code-review skill (7 dimensions: correctness, security, performance, code quality, architecture, testing, language-specific)...',
+  forwardToAI:
+    'use the code-review skill to review all uncommitted changes. Check all 7 dimensions: correctness, security, performance, code quality, architecture & design, testing, and language-specific issues.',
+})
+
+const simplifyCmd = gitDiffBridgeCmd({
+  label: 'Simplify',
+  noChangesHint:
+    'No uncommitted changes to simplify.\n\nMake changes first, then run /simplify for cleanup review.',
+  runningMsg:
+    'Running cleanup review — 4 passes: reuse, simplification, efficiency, abstraction level...',
+  forwardToAI:
+    'use the self-review skill to review these uncommitted changes. Focus on 4 cleanup passes: 1) Reuse — find duplicated logic, replace with existing helpers; 2) Simplification — flatten nesting, remove redundant state and dead code; 3) Efficiency — fix repeated object creation, unnecessary I/O, memory issues; 4) Abstraction Level — ensure code sits at the right architectural layer. Apply equivalent transformations only — do NOT change logic or fix bugs.',
+})
+
+const verifyCmd = gitDiffBridgeCmd({
+  label: 'Verify',
+  noChangesHint:
+    'No uncommitted changes to verify.\n\nMake changes first, then run /verify for runtime verification.',
+  runningMsg:
+    'Running runtime verification — observing actual execution behavior (not tests, not typecheck)...',
+  forwardToAI:
+    'verify these uncommitted changes through runtime observation only. For each change: 1) Find the user-facing surface (CLI command, API endpoint, UI interaction); 2) Drive the changed code to execute; 3) Push boundaries — pass null, repeated values, wrong types, interrupt mid-flow (Ctrl-C), resize window; 4) Report verdict per change: PASS (works as expected), FAIL (does not work or breaks something), BLOCKED (cannot reach observable state), SKIP (no runtime surface, e.g. pure documentation). Do NOT run the test suite — observe real execution behavior only.',
+})
+
+const designCmd: CommandHandler = (_ctx, args) => {
   const topic = args.join(' ') || 'the current task'
   return {
     content: `─ Design ─\n\nStarting architectural design session for: ${topic}\n\nExploring approaches, trade-offs, component breakdown, data flow...`,
-    injectMessage: `help me design the architecture for ${topic}. Explore 2-3 approaches with trade-offs, then present a design covering: component breakdown, data flow, interfaces between components, error handling strategy, and testing approach. Use the plan sub-agent if deeper analysis would help. Prefer simplicity — YAGNI.`,
+    forwardToAI: `help me design the architecture for ${topic}. Explore 2-3 approaches with trade-offs, then present a design covering: component breakdown, data flow, interfaces between components, error handling strategy, and testing approach. Use the plan sub-agent if deeper analysis would help. Prefer simplicity — YAGNI.`,
   }
 }
 
@@ -3590,7 +3627,17 @@ const registry = new Map<string, CommandHandler>()
 
 // Session
 registry.set('/help', helpCmd)
-registry.set('/pick', () => ({ content: 'Opening model picker... (use Ctrl+P or /pick)' }))
+const pickCmd: CommandHandler = (ctx) => ({
+  content: `── Model Picker ──
+
+Use ↑↓ to navigate, Enter to select, Esc to close.
+
+Current: ${ctx.providerId} / ${ctx.modelId}
+Available: ${ctx.config.providers.filter((p) => p.status === 'active').length} providers, ${ctx.config.providers.flatMap((p) => p.models.filter((m) => m.status === 'active')).length} models
+
+Tip: Press Ctrl+P or type /pick from the chat input.`,
+})
+registry.set('/pick', pickCmd)
 registry.set('/version', versionCmd)
 registry.set('/clear', clearCmd)
 registry.set('/exit', exitCmd)
@@ -3618,6 +3665,7 @@ registry.set('/providers', providersCmd)
 registry.set('/config', configCmd)
 registry.set('/fast', fastCmd)
 registry.set('/effort', effortCmd)
+registry.set('/switch', switchCmd)
 
 // Tools & Skills
 registry.set('/tools', toolsCmd)
@@ -3769,8 +3817,8 @@ const COMMAND_DESCRIPTIONS: Record<string, string> = {
   '/plugin-disable': 'Disable an enabled plugin',
   '/plan': 'Enter plan mode',
   '/no-plan': 'Exit plan mode',
-  '/tdd': 'TDD mode',
-  '/todos': 'Task management',
+  '/tdd': 'Test-Driven Development workflow (RED → GREEN → REFACTOR)',
+  '/todos': 'Task management (list/create tasks)',
   '/tasks': 'Background tasks',
   '/review': 'Code review workflow',
   '/pr-comments': 'PR review summary',
@@ -3795,7 +3843,7 @@ const COMMAND_DESCRIPTIONS: Record<string, string> = {
   '/agents': 'Agent view dashboard',
   '/bg': 'Run a background agent task',
   '/artifact': 'Manage artifacts',
-  '/schedule': 'View scheduled tasks',
+  '/schedule': 'View scheduled tasks and cron jobs',
   '/commit': 'Generate commit message and review staged changes',
   '/push': 'Push the current branch',
   '/pr': 'Create a pull request',