@miphamai/cli 0.7.5 → 0.7.7

package/package.json

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

package/src/mcp/transport.ts

@@ -3,7 +3,7 @@ import type { JsonRpcRequest, JsonRpcResponse, JsonRpcNotification } from './typ
 
 type NotificationHandler = (notification: JsonRpcNotification) => void
 
-const REQUEST_TIMEOUT_MS = 30_000
+const REQUEST_TIMEOUT_MS = 60_000
 
 // ── Environment variable security: block sensitive vars from MCP subprocess ──
 //

package/src/ui/app.tsx

@@ -175,9 +175,12 @@ export function App({
           return
         }
 
+        let injectMessage: string | undefined
+
         const handler = getCommand(command)
         if (handler) {
           const result = await handler(mkCtx(), args)
+          injectMessage = result.injectMessage
           setMessages((prev) => [
             ...prev,
             { role: 'user', content: input },
@@ -202,8 +205,15 @@ export function App({
             }
           }
         }
-        // Unknown slash command or handler returned: proceed to normal AI processing
-        return
+
+        // Bridge: if command set injectMessage, route to AI processing
+        if (injectMessage) {
+          input = injectMessage
+          // fall through to normal AI processing below
+        } else {
+          // Unknown slash command or handler returned: proceed to normal AI processing
+          return
+        }
       }
 
       // ── Normal message processing (AI chat) ──

package/src/ui/commands.ts

@@ -40,6 +40,8 @@ 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
 }
 
 type CommandHandler = (
@@ -1088,6 +1090,18 @@ const branchCmd: CommandHandler = (ctx, args) => {
   }
 }
 
+/** Parse human-readable interval to seconds. Returns null if invalid. */
+function parseInterval(raw: string): number | null {
+  const m = raw.trim().match(/^(\d+)\s*(s|sec|m|min|h|hr|hour)$/i)
+  if (!m) return null
+  const n = parseInt(m[1]!, 10)
+  const unit = m[2]!.toLowerCase()
+  if (unit === 's' || unit === 'sec') return n
+  if (unit === 'm' || unit === 'min') return n * 60
+  if (unit === 'h' || unit === 'hr' || unit === 'hour') return n * 3600
+  return null
+}
+
 const loopCmd: CommandHandler = async (_ctx, args) => {
   const sub = args[0]
 
@@ -1166,24 +1180,23 @@ const loopCmd: CommandHandler = async (_ctx, args) => {
           /loop 5m check the deploy status
           /loop init              Create vault in current directory
           /loop init ~/my-project Create vault in specific directory
-
-        Note: Continuous looping requires session persistence, coming in a future release.
       `,
     }
   }
 
   const interval = args[0]!
   const prompt = args.slice(1).join(' ')
+  const seconds = parseInterval(interval)
 
-  return {
-    content: stripIndent`
-      ── Loop Configured ──
-      Interval:  ${interval}
-      Prompt:    "${prompt}"
+  if (seconds === null) {
+    return {
+      content: `── Invalid Interval ──\n\n"${interval}" is not a recognised interval.\n\nUse formats like: 10s, 5m, 1h, 30min, 2hr`,
+    }
+  }
 
-      Loop scheduling infrastructure is being built.
-      For now, manually re-run: /loop ${interval} ${prompt}
-    `,
+  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."`,
   }
 }
 
@@ -1191,14 +1204,15 @@ const scheduleCmd: CommandHandler = (_ctx) => ({
   content: stripIndent`
     ── Scheduled Tasks ──
 
-    No scheduled tasks configured.
+    Active loops are managed via ScheduleWakeup (in-session) and
+    CronCreate (durable, survives restarts).
 
-    Schedule infrastructure is being built. Coming features:
-    • Cron-based scheduling (CronCreate tool)
-    • One-shot and recurring tasks
-    • Durable persistence across sessions
+    Use /loop <interval> <prompt> to start a recurring task.
+    Use CronList to view all scheduled jobs.
+    Use CronDelete <id> to cancel a durable job.
 
-    Use /loop for simple repetition in the current session.
+    The ScheduleWakeup mechanism automatically re-schedules on
+    each wake, creating a self-perpetuating loop within the session.
   `,
 })
 
@@ -1420,39 +1434,78 @@ const issueCmd: CommandHandler = async () => {
 // Code Quality Commands (Claude Code parity)
 // ═══════════════════════════════════════════════════════════════
 
-const simplifyCmd: CommandHandler = async () => {
+// ═══════════════════════════════════════════════════════════════
+// 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()
-    const changed = execSync('git diff --name-only', { encoding: 'utf-8', timeout: 3000 }).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',
+      }
+    }
+    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 review.\n\nRun /simplify after making changes to review for reuse, simplification, and quality improvements.',
+          '─ Simplify ─\n\nNo uncommitted changes to simplify.\n\nMake changes first, then run /simplify for cleanup review.',
       }
     }
+    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) {
+      return {
+        content:
+          '─ Verify ─\n\nNo uncommitted changes to verify.\n\nMake changes first, then run /verify for runtime verification.',
+      }
+    }
     return {
-      content: [
-        '── Simplify Review ──',
-        '',
-        'Changed files:',
-        diff,
-        '',
-        'To run simplification review, type: "review these changes for simplification and quality"',
-        '',
-        'This will check for:',
-        '  • Code reuse opportunities',
-        '  • Overly complex logic',
-        '  • Dead code removal',
-        '  • Style and consistency',
-        '',
-        `Files to review: ${changed.split('\n').length}`,
-      ].join('\n'),
+      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: '── Simplify ──\n\nCould not detect changes. Are you in a git repository?' }
+    return { content: '─ Verify ─\n\nCould not detect changes. Are you in a git repository?' }
+  }
+}
+
+const designCmd: CommandHandler = async (_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.`,
   }
 }
 
@@ -3495,8 +3548,11 @@ const commandsListCmd: CommandHandler = () => {
     '/push': 'Workflow',
     '/pr': 'Workflow',
     '/issue': 'Workflow',
-    '/simplify': 'Workflow',
-    '/lint': 'Workflow',
+    '/code-review': 'Code Quality',
+    '/simplify': 'Code Quality',
+    '/verify': 'Code Quality',
+    '/design': 'Code Quality',
+    '/lint': 'Code Quality',
     '/files': 'Session & Identity',
     '/stats': 'Session & Identity',
     '/summary': 'Session & Identity',
@@ -3634,7 +3690,10 @@ registry.set('/pr', prCmd)
 registry.set('/issue', issueCmd)
 
 // Code Quality (Claude Code parity)
+registry.set('/code-review', codeReviewCmd)
 registry.set('/simplify', simplifyCmd)
+registry.set('/verify', verifyCmd)
+registry.set('/design', designCmd)
 registry.set('/lint', lintCmd)
 
 // Session Enhancement (Claude Code parity)
@@ -3741,7 +3800,10 @@ const COMMAND_DESCRIPTIONS: Record<string, string> = {
   '/push': 'Push the current branch',
   '/pr': 'Create a pull request',
   '/issue': 'File a GitHub issue',
-  '/simplify': 'Review code for reuse, simplification, and quality',
+  '/code-review': 'Review code for bugs, security, performance (7 dimensions)',
+  '/simplify': 'Cleanup-only review: reuse, simplification, efficiency, abstraction',
+  '/verify': 'Runtime verification — observe actual execution, not tests',
+  '/design': 'Start architectural design session — explore approaches and trade-offs',
   '/lint': 'Run linting on the project',
   '/files': 'List files in current working directory',
   '/stats': 'Show session usage statistics',