subagent-cli 0.3.0 → 0.3.2

package/README.md

@@ -1,6 +1,6 @@
-# sa — Morph Code
+# mc — Morph Code
 
-A fork of Claude Code with multi-provider LLM support, WarpGrep semantic code search, and subagent orchestration. Runs from source with Bun.
+A compiled fork of Claude Code with WarpGrep semantic code search, multi-provider LLM support, and subagent orchestration. Ships as a single native binary per platform.
 
 ## Install
 
@@ -11,96 +11,103 @@ curl -fsSL subagents.com/install | bash
 Or with npm:
 
 ```bash
-npm install -g subagent-cli
+npm install -g @morphllm/morphcode
 ```
 
-Requires [Bun](https://bun.sh) runtime.
-
 ## Usage
 
 ```bash
 # Interactive mode
-sa
+mc
 
 # Single prompt
-sa -p "refactor the auth module"
+mc -p "refactor the auth module"
 
 # Print mode (non-interactive, for scripts)
-sa -p "explain this codebase" --print
+mc -p "explain this codebase" --print
 
 # Specify model
-sa --model claude-sonnet-4-6
-sa --model opus
+mc --model claude-sonnet-4-6
+mc --model opus
 
 # List available agents
-sa agents
+mc agents
 ```
 
 ## What's different from Claude Code
 
-**Multi-provider LLM** — Uses [pi-ai](https://github.com/badlogic/pi-mono) under the hood. Set `PI_ENGINE=on` to route through OpenAI, Google, Mistral, or any supported provider instead of Anthropic.
+**WarpGrep agent** — Semantic code search powered by Morph. The `warpgrep` subagent understands code structure, not just text patterns. Always registered alongside Explore and Plan.
 
-**WarpGrep agent** — Semantic code search powered by Morph. When `MORPH_API_KEY` is set, a `warpgrep` subagent becomes available that understands code structure, not just text patterns.
+**Compiled binary** — Ships as a native Mach-O / ELF binary (like Claude Code itself). Starts instantly, no runtime dependencies.
 
-**Explore & Plan agents** — Always enabled. The Explore agent prefers WarpGrep over regex grep when available.
+**Multi-provider LLM** — Set `PI_ENGINE=on` to route through OpenAI, Google, Mistral, or any provider supported by pi-ai.
 
-**Subagent tools** — WarpGrep and FastApply (smart code editing) are registered as first-class tools, available to all agents.
+**Explore & Plan agents** — Always enabled. The Explore agent prefers WarpGrep over regex grep when available.
 
 ## Agents
 
 ```
-$ sa agents
+$ mc agents
 
-9 active agents
+6 active agents
 
 Built-in agents:
-  Explore    · haiku    — Fast codebase exploration (uses WarpGrep when available)
-  Plan       · inherit  — Architecture and implementation planning
-  warpgrep   · haiku    — Semantic code search via Morph
-  general-purpose · inherit — Research, code search, multi-step tasks
-  claude-code-guide · haiku — Questions about features and usage
-  statusline-setup  · sonnet — Configure status line
+  Explore          · haiku    — Fast codebase exploration
+  Plan             · inherit  — Architecture and implementation planning
+  warpgrep         · haiku    — Semantic code search via Morph
+  general-purpose  · inherit  — Research, code search, multi-step tasks
+  claude-code-guide · haiku   — Questions about features and usage
+  statusline-setup · sonnet   — Configure status line
 ```
 
 ## Environment variables
 
 | Variable | Required | Purpose |
 |----------|----------|---------|
-| `ANTHROPIC_API_KEY` | Yes (or OAuth) | Anthropic API access |
-| `MORPH_API_KEY` | No | Enables WarpGrep, FastApply, and warpgrep agent |
+| `ANTHROPIC_API_KEY` | Yes (or OAuth via `mc auth login`) | Anthropic API access |
+| `MORPH_API_KEY` | No | Enables WarpGrep and FastApply tools |
 | `OPENAI_API_KEY` | No | For PI_ENGINE multi-provider mode |
 | `GOOGLE_API_KEY` | No | For PI_ENGINE multi-provider mode |
 | `PI_ENGINE` | No | Set to `on` to route LLM calls through pi-ai |
 
+## Platform binaries
+
+Published to npm as platform-specific packages:
+
+| Platform | Package |
+|----------|---------|
+| macOS Apple Silicon | `@morphllm/morphcode-darwin-arm64` |
+| macOS Intel | `@morphllm/morphcode-darwin-x64` |
+| Linux x64 | `@morphllm/morphcode-linux-x64` |
+| Linux arm64 | `@morphllm/morphcode-linux-arm64` |
+| Windows x64 | `@morphllm/morphcode-windows-x64` |
+
 ## Development
 
 ```bash
-# Run from source
-cd packages/subagentscccli
+# Run from source (requires Bun)
+cd packages/subagent-cli
 bun run --preload ./stubs/globals.ts ./src/entrypoints/cli.tsx
 
-# Run tests (88 tests)
+# Build native binary
+bun build --compile _entry.ts --outfile dist/mc --target bun
+
+# Run tests
 npx vitest --run
 
-# Check agents
+# List agents
 bun run --preload ./stubs/globals.ts ./src/entrypoints/cli.tsx agents
-
-# Verify version
-bun run --preload ./stubs/globals.ts ./src/entrypoints/cli.tsx --version
 ```
 
 ## Architecture
 
-Built on the Claude Code v2.1.88 source with these modifications:
+Built on Claude Code v2.1.88 source, compiled to a native binary via `bun build --compile`.
 
-- `src/engine/` — Pi-mono integration layer (PiAgentAdapter, MessageMapper, ToolAdapter, ModelResolver, CostMapper, PermissionBridge, SubagentTools)
-- `src/query/deps.ts` — LLM call routing (Anthropic SDK default, pi-ai when `PI_ENGINE=on`)
-- `src/tools/AgentTool/built-in/warpGrepAgent.ts` — WarpGrep subagent definition
+Key modifications:
+- `src/tools/AgentTool/built-in/warpGrepAgent.ts` — WarpGrep subagent
 - `src/tools/WarpGrepTool/WarpGrepTool.ts` — WarpGrep as a Claude Code Tool
 - `src/tools/AgentTool/builtInAgents.ts` — Explore/Plan always enabled, warpgrep registered
-- `stubs/` — Runtime stubs for unavailable Anthropic-internal packages
-- `bin/sa.js` — Bun launcher entry point
-
-## License
-
-Claude Code source is property of Anthropic. This fork is for internal use.
+- `src/engine/` — Pi-mono integration layer for multi-provider LLM
+- `src/query/deps.ts` — LLM call routing (Anthropic default, pi-ai when `PI_ENGINE=on`)
+- `stubs/` — Build-time stubs for unavailable Anthropic-internal packages
+- `.github/workflows/publish-morphcode.yml` — Multi-platform binary build and npm publish

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "subagent-cli",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "sa — Morph Code CLI (Claude Code fork with multi-provider LLM, WarpGrep, and subagent support)",
   "type": "module",
   "bin": {
@@ -21,8 +21,7 @@
     "typecheck": "tsc --noEmit",
     "test": "vitest --run",
     "clean": "rm -rf dist",
-    "start": "bun run --preload ./stubs/globals.ts ./src/entrypoints/cli.tsx",
-    "postinstall": "node -e \"const f=require(\"fs\"),p=require(\"path\");try{const s=p.join(__dirname,\"node_modules\",\"src\");if(!f.existsSync(s)){f.mkdirSync(p.join(__dirname,\"node_modules\"),{recursive:true});f.symlinkSync(p.join(__dirname,\"src\"),s)}}catch{}\""
+    "start": "bun run --preload ./stubs/globals.ts ./src/entrypoints/cli.tsx"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.80.0",

package/src/commands/install-notch/index.ts

@@ -0,0 +1,12 @@
+import type { Command } from '../../commands.js'
+
+const installNotch = {
+  type: 'local' as const,
+  name: 'install-notch',
+  description: 'Install the macOS notch helper (shows agent status with a pixel frog)',
+  isEnabled: () => process.platform === 'darwin',
+  supportsNonInteractive: false,
+  load: () => import('./install-notch.js'),
+} satisfies Command
+
+export default installNotch

package/src/commands/install-notch/install-notch.ts

@@ -0,0 +1,151 @@
+/**
+ * /install-notch command
+ *
+ * Builds and installs the SubagentNotch macOS helper app.
+ * The app lives in ~/.claude/helpers/SubagentNotch.app and is launched
+ * automatically via SessionStart hooks.
+ *
+ * Steps:
+ *   1. Check we're on macOS
+ *   2. Build the Swift app from helpers/notch/
+ *   3. Copy the built .app bundle to ~/.claude/helpers/
+ *   4. Write ~/.claude/notch.json with the port config
+ *   5. Register hooks in project settings
+ */
+
+import { execSync, execFileSync } from 'child_process'
+import { existsSync, mkdirSync, writeFileSync, cpSync } from 'fs'
+import { homedir } from 'os'
+import { join, resolve, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import type { LocalCommandResult } from '../../commands.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+const NOTCH_PORT = 27182
+const HELPERS_DIR = join(homedir(), '.claude', 'helpers')
+const APP_NAME = 'SubagentNotch'
+const CONFIG_PATH = join(homedir(), '.claude', 'notch.json')
+
+export async function call(): Promise<LocalCommandResult> {
+  // Step 1: Platform check
+  if (process.platform !== 'darwin') {
+    return {
+      type: 'text',
+      value: 'The notch helper is only available on macOS.',
+    }
+  }
+
+  // Step 2: Check for Swift toolchain
+  try {
+    execFileSync('swift', ['--version'], { stdio: 'pipe' })
+  } catch {
+    return {
+      type: 'text',
+      value:
+        'Swift is not installed. Install Xcode or Xcode Command Line Tools:\n' +
+        '  xcode-select --install',
+    }
+  }
+
+  // Step 3: Find the Swift source
+  // Look relative to the CLI package root, then fall back to monorepo root
+  const candidates = [
+    resolve(__dirname, '../../../../helpers/notch'),
+    resolve(__dirname, '../../../../../helpers/notch'),
+    resolve(__dirname, '../../../../../../helpers/notch'),
+  ]
+  const sourceDir = candidates.find(d => existsSync(join(d, 'Package.swift')))
+
+  if (!sourceDir) {
+    return {
+      type: 'text',
+      value:
+        'Could not find helpers/notch source directory.\n' +
+        'Make sure you are running from the subagents monorepo.',
+    }
+  }
+
+  // Step 4: Build the Swift app
+  try {
+    execSync('swift build -c release --quiet', {
+      cwd: sourceDir,
+      stdio: 'pipe',
+      timeout: 120_000, // 2 minute timeout
+    })
+  } catch (err: unknown) {
+    const message =
+      err instanceof Error ? err.message : String(err)
+    return {
+      type: 'text',
+      value: `Swift build failed:\n${message}`,
+    }
+  }
+
+  // Step 5: Copy binary to ~/.claude/helpers/
+  mkdirSync(HELPERS_DIR, { recursive: true })
+
+  const builtBinary = join(
+    sourceDir,
+    '.build',
+    'release',
+    APP_NAME,
+  )
+
+  if (!existsSync(builtBinary)) {
+    return {
+      type: 'text',
+      value: 'Build succeeded but binary not found. Check the Swift build output.',
+    }
+  }
+
+  const destBinary = join(HELPERS_DIR, APP_NAME)
+
+  try {
+    // Kill any existing instance before overwriting
+    try {
+      execSync(`pkill -f "${APP_NAME}" 2>/dev/null || true`, { stdio: 'pipe' })
+    } catch {
+      // Ignore — might not be running
+    }
+
+    cpSync(builtBinary, destBinary)
+    // Make executable
+    execSync(`chmod +x "${destBinary}"`, { stdio: 'pipe' })
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    return {
+      type: 'text',
+      value: `Failed to install binary:\n${message}`,
+    }
+  }
+
+  // Step 6: Write config
+  const config = {
+    port: NOTCH_PORT,
+    binary: destBinary,
+    installedAt: new Date().toISOString(),
+  }
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2))
+
+  // Step 7: Remove quarantine attribute (Gatekeeper bypass for local builds)
+  try {
+    execSync(`xattr -cr "${destBinary}"`, { stdio: 'pipe' })
+  } catch {
+    // Non-critical — might not have xattr issues
+  }
+
+  return {
+    type: 'text',
+    value: [
+      `Notch helper installed to ${destBinary}`,
+      `Listening on port ${NOTCH_PORT}`,
+      '',
+      'The frog will appear in your MacBook notch when a session starts.',
+      'Hook events are published automatically to the helper.',
+      '',
+      'To uninstall: rm ~/.claude/helpers/SubagentNotch ~/.claude/notch.json',
+    ].join('\n'),
+  }
+}

package/src/commands.ts

@@ -28,6 +28,7 @@ import keybindings from './commands/keybindings/index.js'
 import login from './commands/login/index.js'
 import logout from './commands/logout/index.js'
 import installGitHubApp from './commands/install-github-app/index.js'
+import installNotch from './commands/install-notch/index.js'
 import installSlackApp from './commands/install-slack-app/index.js'
 import breakCache from './commands/break-cache/index.js'
 import mcp from './commands/mcp/index.js'
@@ -283,6 +284,7 @@ const COMMANDS = memoize((): Command[] => [
   init,
   keybindings,
   installGitHubApp,
+  installNotch,
   installSlackApp,
   mcp,
   memory,

package/src/utils/hooks/hookEvents.ts

@@ -4,6 +4,9 @@
  * This module provides a generic event system that is separate from the
  * main message stream. Handlers can register to receive events and decide
  * what to do with them (e.g., convert to SDK messages, log, etc.).
+ *
+ * Secondary listeners (e.g., notch publisher) can register via
+ * addSecondaryHookEventListener() without interfering with the primary handler.
  */
 
 import { HOOK_EVENTS } from 'src/entrypoints/sdk/coreTypes.js'
@@ -57,6 +60,7 @@ export type HookEventHandler = (event: HookExecutionEvent) => void
 const pendingEvents: HookExecutionEvent[] = []
 let eventHandler: HookEventHandler | null = null
 let allHookEventsEnabled = false
+const secondaryListeners: HookEventHandler[] = []
 
 export function registerHookEventHandler(
   handler: HookEventHandler | null,
@@ -78,6 +82,30 @@ function emit(event: HookExecutionEvent): void {
       pendingEvents.shift()
     }
   }
+  // Notify secondary listeners (e.g., notch publisher) — fire-and-forget
+  for (const listener of secondaryListeners) {
+    try {
+      listener(event)
+    } catch {
+      // Secondary listeners must never break the primary event flow
+    }
+  }
+}
+
+/**
+ * Register a secondary listener that receives all emitted hook events.
+ * Unlike the primary handler, secondary listeners are additive — multiple
+ * can coexist. They run fire-and-forget and errors are silently caught.
+ * Returns an unsubscribe function.
+ */
+export function addSecondaryHookEventListener(
+  listener: HookEventHandler,
+): () => void {
+  secondaryListeners.push(listener)
+  return () => {
+    const idx = secondaryListeners.indexOf(listener)
+    if (idx !== -1) secondaryListeners.splice(idx, 1)
+  }
 }
 
 function shouldEmit(hookEvent: string): boolean {
@@ -189,4 +217,5 @@ export function clearHookEventState(): void {
   eventHandler = null
   pendingEvents.length = 0
   allHookEventsEnabled = false
+  secondaryListeners.length = 0
 }

package/src/utils/hooks.ts

@@ -4110,6 +4110,14 @@ export async function executeSessionEndHooks(
     timeoutMs = TOOL_HOOK_EXECUTION_TIMEOUT_MS,
   } = options || {}
 
+  // Notify the macOS notch helper before running session end hooks
+  try {
+    const { cleanupNotchBridge } = await import('./sessionStart.js')
+    cleanupNotchBridge()
+  } catch {
+    // Non-critical — notch cleanup failure must never block session end
+  }
+
   const hookInput: SessionEndHookInput = {
     ...createBaseHookInput(undefined),
     hook_event_name: 'SessionEnd',

package/src/utils/notchBridge.ts

@@ -0,0 +1,78 @@
+/**
+ * Notch Bridge
+ *
+ * Connects the CLI's hook event system to the SubagentNotch macOS helper.
+ * Call initNotchBridge() once at session start. It registers a secondary
+ * hook event listener that translates hook events into notch events and
+ * publishes them over HTTP.
+ *
+ * This module is a thin adapter between two systems:
+ *   - Input:  HookExecutionEvent from hookEvents.ts
+ *   - Output: AgentEvent JSON to the notch helper's HTTP server
+ */
+
+import { addSecondaryHookEventListener } from './hooks/hookEvents.js'
+import type { HookExecutionEvent } from './hooks/hookEvents.js'
+import {
+  isNotchConfigured,
+  publishNotchEvent,
+  setNotchSessionId,
+} from './notchPublisher.js'
+
+/**
+ * Map from hook event names to notch event names.
+ * SessionStart/SessionEnd are handled manually (not via the listener)
+ * to avoid duplicate events.
+ */
+const EVENT_MAP: Record<string, string> = {
+  PreToolUse: 'tool_start',
+  PostToolUse: 'tool_end',
+  SubagentStart: 'subagent_start',
+  SubagentStop: 'subagent_stop',
+  TaskCreated: 'task_created',
+  TaskCompleted: 'task_completed',
+  Stop: 'stop',
+  PostToolUseFailure: 'error',
+}
+
+/** Hook events we forward on 'started' (beginning of action). */
+const FORWARD_ON_STARTED = new Set(['PreToolUse', 'SubagentStart'])
+
+/**
+ * Initialize the notch bridge for a session.
+ * No-ops on non-macOS or when the notch helper isn't installed.
+ * Returns an unsubscribe function that sends session_end and cleans up.
+ */
+export function initNotchBridge(sessionId: string): () => void {
+  if (!isNotchConfigured()) return () => {}
+
+  setNotchSessionId(sessionId)
+
+  // Notify the notch helper that a session started
+  publishNotchEvent({ event: 'session_start' })
+
+  // Listen to hook events and forward relevant ones to the notch helper
+  const unsubscribe = addSecondaryHookEventListener(
+    (event: HookExecutionEvent) => {
+      const notchEvent = EVENT_MAP[event.hookEvent]
+      if (!notchEvent) return
+
+      // Forward 'started' for beginning-of-action events (tool/subagent start),
+      // 'response' for end-of-action events (tool end, task complete, stop, error)
+      const wantedType = FORWARD_ON_STARTED.has(event.hookEvent)
+        ? 'started'
+        : 'response'
+      if (event.type !== wantedType) return
+
+      publishNotchEvent({
+        event: notchEvent,
+        toolName: event.hookName,
+      })
+    },
+  )
+
+  return () => {
+    publishNotchEvent({ event: 'session_end' })
+    unsubscribe()
+  }
+}

package/src/utils/notchPublisher.ts

@@ -0,0 +1,111 @@
+/**
+ * Notch Event Publisher
+ *
+ * Publishes hook lifecycle events to the SubagentNotch macOS helper app
+ * via HTTP POST to a local port. Fire-and-forget — never blocks the CLI.
+ *
+ * The notch helper listens on port 27182 by default. The port is stored
+ * in ~/.claude/notch.json after installation.
+ */
+
+import { readFileSync } from 'fs'
+import http from 'http'
+import { homedir } from 'os'
+import { join } from 'path'
+
+// Default port (e ≈ 2.7182...)
+const DEFAULT_PORT = 27182
+
+// Config file written by /install-notch
+const CONFIG_PATH = join(homedir(), '.claude', 'notch.json')
+
+/** Cached port so we only read the config file once. */
+let cachedPort: number | null = null
+let portResolved = false
+
+/** Cached session ID for the current CLI session. */
+let currentSessionId: string | null = null
+
+// MARK: - Public API
+
+/** Set the session ID for all future events. Called once at session start. */
+export function setNotchSessionId(sessionId: string): void {
+  currentSessionId = sessionId
+}
+
+/** Check if the notch helper is configured (macOS only). */
+export function isNotchConfigured(): boolean {
+  if (process.platform !== 'darwin') return false
+  return getPort() !== null
+}
+
+/**
+ * Publish an event to the notch helper. Fire-and-forget.
+ * Safe to call on any platform — silently no-ops on non-macOS.
+ */
+export function publishNotchEvent(event: {
+  event: string
+  agentId?: string
+  toolName?: string
+  taskSubject?: string
+  message?: string
+}): void {
+  if (process.platform !== 'darwin') return
+
+  const port = getPort()
+  if (!port) return
+
+  const payload = JSON.stringify({
+    sessionId: currentSessionId ?? 'unknown',
+    event: event.event,
+    agentId: event.agentId ?? null,
+    toolName: event.toolName ?? null,
+    taskSubject: event.taskSubject ?? null,
+    message: event.message ?? null,
+    timestamp: Date.now() / 1000,
+  })
+
+  // Fire-and-forget HTTP POST — errors are silently ignored.
+  // We use raw http.request to avoid adding dependencies.
+  const req = http.request(
+    {
+      hostname: '127.0.0.1',
+      port,
+      path: '/event',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(payload),
+      },
+      timeout: 500, // 500ms max — never slow down the CLI
+    },
+    () => {
+      // Response received — we don't care about the body
+    },
+  )
+
+  req.on('error', () => {
+    // Notch helper not running — that's fine, silently ignore
+  })
+
+  req.write(payload)
+  req.end()
+}
+
+// MARK: - Config
+
+/** Read the port from ~/.claude/notch.json (cached after first read). */
+function getPort(): number | null {
+  if (portResolved) return cachedPort
+
+  portResolved = true
+  try {
+    const raw = readFileSync(CONFIG_PATH, 'utf-8')
+    const config = JSON.parse(raw)
+    cachedPort = typeof config.port === 'number' ? config.port : DEFAULT_PORT
+  } catch {
+    // Config doesn't exist — notch not installed
+    cachedPort = null
+  }
+  return cachedPort
+}

package/src/utils/sessionStart.ts

@@ -8,6 +8,7 @@ import { updateWatchPaths } from './hooks/fileChangedWatcher.js'
 import { shouldAllowManagedHooksOnly } from './hooks/hooksConfigSnapshot.js'
 import { executeSessionStartHooks, executeSetupHooks } from './hooks.js'
 import { logError } from './log.js'
+import { initNotchBridge } from './notchBridge.js'
 import { loadPluginHooks } from './plugins/loadPluginHooks.js'
 
 type SessionStartHooksOptions = {
@@ -24,6 +25,7 @@ type SessionStartHooksOptions = {
 // joined later — rippling a structural return-type change through that
 // handoff would touch five callsites for what is a print-mode-only value).
 let pendingInitialUserMessage: string | undefined
+let notchCleanup: (() => void) | null = null
 
 export function takeInitialUserMessage(): string | undefined {
   const v = pendingInitialUserMessage
@@ -31,6 +33,12 @@ export function takeInitialUserMessage(): string | undefined {
   return v
 }
 
+/** Clean up the notch bridge. Called from session end. */
+export function cleanupNotchBridge(): void {
+  notchCleanup?.()
+  notchCleanup = null
+}
+
 // Note to CLAUDE: do not add ANY "warmup" logic. It is **CRITICAL** that you do not add extra work on startup.
 export async function processSessionStartHooks(
   source: 'startup' | 'resume' | 'clear' | 'compact',
@@ -47,6 +55,13 @@ export async function processSessionStartHooks(
   if (isBareMode()) {
     return []
   }
+
+  // Connect the macOS notch helper (no-ops on non-macOS or if not installed)
+  if (sessionId) {
+    notchCleanup?.()
+    notchCleanup = initNotchBridge(sessionId)
+  }
+
   const hookMessages: HookResultMessage[] = []
   const additionalContexts: string[] = []
   const allWatchPaths: string[] = []