@miphamai/cli 0.36.0 → 0.36.1

package/package.json

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

package/src/agent-view/agent-view-manager.ts

@@ -34,11 +34,14 @@ export interface AgentSession {
   branch?: string
   /** Created PR URL (if requested) */
   prUrl?: string
+  /** Working directory the session was spawned from (used for directory grouping). */
+  directory: string
 }
 
 export interface CreateSessionOptions {
   provider?: string
   model?: string
+  directory?: string
 }
 
 export interface SessionPeek {
@@ -48,6 +51,11 @@ export interface SessionPeek {
 
 export type StatusGroups = Record<SessionStatus, AgentSession[]>
 
+export interface DirectoryGroup {
+  directory: string
+  sessions: AgentSession[]
+}
+
 export class AgentViewManager {
   private sessions: Map<string, AgentSession> = new Map()
   private sessionOrder: string[] = []
@@ -66,6 +74,7 @@ export class AgentViewManager {
       provider: options.provider ?? 'unknown',
       model: options.model ?? 'unknown',
       task,
+      directory: options.directory ?? process.cwd(),
       createdAt: new Date(),
       elapsedMs: 0,
       messages: [],
@@ -109,6 +118,27 @@ export class AgentViewManager {
     return groups
   }
 
+  /**
+   * Group all sessions by their working directory (v2.1.229 session-grouping alignment).
+   * Returns groups sorted alphabetically by directory path.
+   */
+  groupByDirectory(): DirectoryGroup[] {
+    const groups = new Map<string, AgentSession[]>()
+
+    for (const id of this.sessionOrder) {
+      const session = this.sessions.get(id)
+      if (!session) continue
+      const dir = session.directory || '(unknown)'
+      const existing = groups.get(dir)
+      if (existing) existing.push(session)
+      else groups.set(dir, [session])
+    }
+
+    return Array.from(groups.entries())
+      .map(([directory, sessions]) => ({ directory, sessions }))
+      .sort((a, b) => a.directory.localeCompare(b.directory))
+  }
+
   /**
    * Get a session by ID.
    */

package/src/agent-view/dashboard.tsx

@@ -30,7 +30,7 @@ const STATUS_HEADERS: Record<string, { label: string; color: string }> = {
 export function AgentViewDashboard({ manager, onAttach, onExit }: DashboardProps) {
   const [selectedIndex, setSelectedIndex] = useState(0)
   const [peekingSessionId, setPeekingSessionId] = useState<string | null>(null)
-  const [_groupBy, setGroupBy] = useState<'status' | 'directory'>('status')
+  const [groupBy, setGroupBy] = useState<'status' | 'directory'>('status')
   const [feedback, setFeedback] = useState<string | null>(null)
 
   // Flash a brief feedback message that auto-clears
@@ -41,37 +41,53 @@ export function AgentViewDashboard({ manager, onAttach, onExit }: DashboardProps
 
   // Build a flat list of sessions in group order, with group headers
   const flatList = useMemo(() => {
-    const groups = manager.groupByStatus()
     const result: Array<
-      | { type: 'header'; status: string; label: string; color: string; count: number }
+      | { type: 'header'; key: string; label: string; color: string; count: number }
       | { type: 'session'; session: AgentSession }
     > = []
 
-    const statusOrder: Array<keyof typeof STATUS_HEADERS> = [
-      'working',
-      'needs-input',
-      'completed',
-      'failed',
-    ]
+    if (groupBy === 'directory') {
+      for (const group of manager.groupByDirectory()) {
+        result.push({
+          type: 'header',
+          key: `dir-${group.directory}`,
+          label: group.directory,
+          color: 'blue',
+          count: group.sessions.length,
+        })
 
-    for (const _status of statusOrder) {
-      const status = _status as SessionStatus
-      const sessions = groups[status] ?? []
-      result.push({
-        type: 'header',
-        status,
-        label: STATUS_HEADERS[status]!.label,
-        color: STATUS_HEADERS[status]!.color,
-        count: sessions.length,
-      })
+        for (const session of group.sessions) {
+          result.push({ type: 'session', session })
+        }
+      }
+    } else {
+      const groups = manager.groupByStatus()
+      const statusOrder: Array<keyof typeof STATUS_HEADERS> = [
+        'working',
+        'needs-input',
+        'completed',
+        'failed',
+      ]
+
+      for (const _status of statusOrder) {
+        const status = _status as SessionStatus
+        const sessions = groups[status] ?? []
+        result.push({
+          type: 'header',
+          key: `status-${status}`,
+          label: STATUS_HEADERS[status]!.label,
+          color: STATUS_HEADERS[status]!.color,
+          count: sessions.length,
+        })
 
-      for (const session of sessions) {
-        result.push({ type: 'session', session })
+        for (const session of sessions) {
+          result.push({ type: 'session', session })
+        }
       }
     }
 
     return result
-  }, [manager])
+  }, [manager, groupBy])
 
   // Flatten sessions only for navigation (skip headers)
   const sessionsOnly = useMemo(
@@ -106,7 +122,7 @@ export function AgentViewDashboard({ manager, onAttach, onExit }: DashboardProps
     // Ctrl+T — toggle group by (status ↔ directory)
     if (key.ctrl && input === 't') {
       setGroupBy((prev) => (prev === 'status' ? 'directory' : 'status'))
-      showFeedback(`Grouped by ${_groupBy === 'status' ? 'directory' : 'status'}`)
+      showFeedback(`Grouped by ${groupBy === 'status' ? 'directory' : 'status'}`)
       return
     }
 
@@ -238,7 +254,7 @@ export function AgentViewDashboard({ manager, onAttach, onExit }: DashboardProps
           {flatList.map((item, _flatIdx) => {
             if (item.type === 'header') {
               return (
-                <Box key={`h-${item.status}`} marginY={1}>
+                <Box key={`h-${item.key}`} marginY={1}>
                   <Text bold color={item.color}>
                     {' '}
                     {item.label} ({item.count})

package/src/core/engine.ts

@@ -377,6 +377,10 @@ export class QueryEngine {
   }
 
   async *process(userInput: string, signal?: AbortSignal): AsyncGenerator<StreamChunk> {
+    // v2.1.229 alignment: reject whitespace-only messages before they reach the
+    // provider API (which would otherwise 400 on an empty/blank message).
+    if (!userInput.trim()) return
+
     // Poll for cross-session messages before each turn
     await this.pollCrossSessionInbox()
 

package/src/core/permission.ts

@@ -9,6 +9,18 @@ import type { PermissionRuleEntry } from '../shared/index.ts'
 import { matchBashRule, compileRule } from './permission-rules'
 import { loadPermissionConfig, nextMode, clampMode, MODE_CYCLE } from './permission-config'
 
+/**
+ * Check if a Bash command is a git/gh operation using a destructive flag
+ * (--force, --amend, --no-verify, --hard) that must never be auto-approved.
+ * v2.1.229 alignment: these rewrite history / force-push, so they fall back
+ * to explicit user confirmation even in auto mode.
+ */
+function hasDangerousGitFlags(input: Record<string, unknown>): boolean {
+  const cmd = (input.command as string) || ''
+  if (!/^(git|gh)\s+/.test(cmd.trim())) return false
+  return /--force(?!-with-lease)\b|--amend\b|--no-verify\b|--hard\b/.test(cmd)
+}
+
 /**
  * Check if a Bash command is a "verification-only" command that should be
  * auto-approved in acceptEdits mode. These are non-destructive read/check
@@ -414,6 +426,10 @@ export class PermissionSystem {
         if (this.isSubAgent && ['Bash', 'Write', 'Edit'].includes(tool.name)) {
           return 'ask'
         }
+        // v2.1.229 alignment: destructive git/gh flags are never auto-approved.
+        if (tool.name === 'Bash' && input && hasDangerousGitFlags(input)) {
+          return 'ask'
+        }
         return 'bypass'
 
       case 'dontAsk':

package/src/workflow/primitives/parallel.ts

@@ -1,11 +1,29 @@
+import os from 'node:os'
+
 /**
  * parallel() — barrier: executes all thunks concurrently, waits for all.
  * Failed thunks resolve to null. Never throws.
  *
- * P0-2 (v2.1.223 alignment): Added concurrency cap (MAX_CONCURRENT = 16)
- * to prevent resource exhaustion from unbounded fan-out.
+ * P0-2 (v2.1.223 alignment): Added concurrency cap (MAX_CONCURRENT) to prevent
+ * resource exhaustion from unbounded fan-out.
+ *
+ * v2.1.229 alignment: detect parallelism via os.availableParallelism() so
+ * CPU-limited containers (cgroup quota) don't fan out to the host core count.
+ * Still capped at 16 to bound resource usage, with a floor of 1.
  */
-const MAX_CONCURRENT = 16
+function detectParallelism(): number {
+  try {
+    if (typeof os.availableParallelism === 'function') {
+      const p = os.availableParallelism()
+      if (typeof p === 'number' && p > 0) return p
+    }
+  } catch {
+    /* fall through to cpus() */
+  }
+  return os.cpus().length || 1
+}
+
+const MAX_CONCURRENT = Math.max(1, Math.min(16, detectParallelism()))
 
 /**
  * Simple async semaphore for concurrency limiting.