@miphamai/cli 0.7.6 → 0.7.8

package/package.json

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

package/src/ui/app.tsx

@@ -175,9 +175,12 @@ export function App({
           return
         }
 
+        let forwardToAI: string | undefined
+
         const handler = getCommand(command)
         if (handler) {
           const result = await handler(mkCtx(), args)
+          forwardToAI = result.forwardToAI
           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 forwardToAI, route the message to AI processing
+        if (forwardToAI) {
+          input = forwardToAI
+          // fall through to normal AI processing below
+        } else {
+          // No handler matched or handler didn't request AI routing — stop here
+          return
+        }
       }
 
       // ── Normal message processing (AI chat) ──

package/src/ui/commands.ts

@@ -40,6 +40,9 @@ export interface CommandResult {
   clearMessages?: boolean
   /** Content to copy to clipboard (handled by caller) */
   copyContent?: 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 = (
@@ -1088,6 +1091,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 +1181,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.`,
+    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."`,
   }
 }
 
@@ -1191,14 +1205,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.
   `,
 })
 
@@ -1417,42 +1432,70 @@ const issueCmd: CommandHandler = async () => {
 }
 
 // ═══════════════════════════════════════════════════════════════
-// Code Quality Commands (Claude Code parity)
+// Code Quality — bridge slash commands to skills (Claude Code parity)
 // ═══════════════════════════════════════════════════════════════
 
-const simplifyCmd: 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) {
+/** 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:
-          '── Simplify ──\n\nNo uncommitted changes to review.\n\nRun /simplify after making changes to review for reuse, simplification, and quality improvements.',
+        content: `─ ${opts.label} ─\n\n${opts.runningMsg}\n\nChanged files:\n${diff}`,
+        forwardToAI: opts.forwardToAI,
+      }
+    } catch {
+      return {
+        content: `─ ${opts.label} ─\n\nCould not detect changes. Are you in a git repository?`,
       }
     }
+  }
+}
 
-    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'),
-    }
-  } catch {
-    return { content: '── Simplify ──\n\nCould not detect changes. Are you in a git repository?' }
+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...`,
+    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.`,
   }
 }
 
@@ -3495,8 +3538,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 +3680,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 +3790,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',