@bahulam/code 0.1.10 → 0.1.12

package/src/terminal/main.mjs

@@ -23,6 +23,64 @@ import { BahulamAuth as Auth } from '../auth/bahulam-auth.mjs';
 const subcommand = process.argv[2];
 const subcommandArgs = process.argv.slice(3);
 
+const PLUGIN_MANAGEMENT_COMMANDS = new Set([
+  'install', 'validate', 'check', 'lint',
+  'list', 'ls', 'remove', 'rm', 'uninstall',
+  'enable', 'disable', 'info', 'update', 'upgrade',
+]);
+
+function parsePluginArgs(argv) {
+  const parsed = {
+    action: null,       // 'open' (default) or a management verb
+    pluginName: null,
+    targetPath: null,
+    source: null,       // install source: git url, tarball, local dir
+    port: 0,
+    open: true,
+    help: false,
+    json: false,
+    global: true,       // install target: ~/.bahulam vs project .bahulam
+    force: false,
+    ref: null,          // git branch/tag/commit
+  };
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    switch (arg) {
+      case '--help':
+      case '-h': parsed.help = true; break;
+      case '--port': parsed.port = Number(argv[++i]) || 0; break;
+      case '--no-open': parsed.open = false; break;
+      case '--json': parsed.json = true; parsed.open = false; break;
+      case '--project': parsed.global = false; break;
+      case '--global': parsed.global = true; break;
+      case '--force': case '-f': parsed.force = true; break;
+      case '--ref': case '--tag': case '--branch': parsed.ref = argv[++i]; break;
+      default:
+        if (!arg.startsWith('-')) positional.push(arg);
+        break;
+    }
+  }
+  if (positional.length && PLUGIN_MANAGEMENT_COMMANDS.has(positional[0].toLowerCase())) {
+    parsed.action = positional.shift().toLowerCase();
+    if (parsed.action === 'install') parsed.source = positional.shift() || null;
+    else if (['validate', 'check', 'lint'].includes(parsed.action)) {
+      // Accepts either a directory path or an installed plugin name.
+      const arg = positional.shift() || null;
+      if (arg && (arg.includes('/') || fs.existsSync?.(arg))) parsed.source = arg;
+      else parsed.pluginName = arg;
+    }
+    else if (['info', 'remove', 'rm', 'uninstall', 'enable', 'disable', 'update', 'upgrade'].includes(parsed.action)) {
+      parsed.pluginName = positional.shift() || null;
+    }
+  } else {
+    parsed.action = 'open';
+    parsed.pluginName = positional.shift() || null;
+    parsed.targetPath = positional.shift() || null;
+  }
+  return parsed;
+}
+
 function parseKeplerSubcommandArgs(command, argv) {
   const parsed = {
     command,
@@ -221,6 +279,18 @@ async function main() {
     return;
   }
 
+  if (subcommand === 'plugin' || subcommand === 'plugins') {
+    const args = parsePluginArgs(subcommandArgs);
+    if (args.action && args.action !== 'open') {
+      const { handlePluginManagementCommand } = await import('../commands/plugin-manage.mjs');
+      await handlePluginManagementCommand(args, { cwd: process.cwd() });
+      return;
+    }
+    const { handlePluginCommand } = await import('../commands/plugin.mjs');
+    await handlePluginCommand(args, { cwd: process.cwd() });
+    return;
+  }
+
   if (subcommand === 'version' || subcommand === '--version' || subcommand === '-v') {
     const { createRequire } = await import('node:module');
     const require = createRequire(import.meta.url);
@@ -236,6 +306,8 @@ async function main() {
   \x1b[1mUsage:\x1b[0m
     bahulam                        Start interactive REPL
     bahulam "instruction"          Run a single instruction
+    bahulam --agent <slug> -p "x"  Run a named agent (local deterministic graph)
+    bahulam --workflow <name> -p   Run a named workflow (local deterministic graph)
     bahulam --headless -p "x"      Non-interactive: auto-approve, JSONL output
     bahulam --headless -p "x" --vision screenshot.png
                               Attach an image via the vision analysis pipeline
@@ -260,6 +332,9 @@ async function main() {
     bahulam workspace list         List recent local workspace sessions
     bahulam local open [path]      Alias for workspace open
 
+  \x1b[1mPlugins:\x1b[0m
+    bahulam plugin <name> [path]   Open a workspace with a named plugin
+
   \x1b[1mAnalytics:\x1b[0m
     bahulam sessions               List recent local sessions
     bahulam stats                  Show aggregate local session stats
@@ -287,7 +362,7 @@ async function main() {
     /architect <query>      Spawn architecture planning agent
     /agents create <name>   Create project-local user-defined agent YAML
     /agents edit <name>     Open a local agent YAML in your editor
-    /agents sync [name]     Sync all or one local agent to Supabase
+    /agents sync [name]     Optionally publish local agents to backend/account
     /attach <image-path>    Attach an image to next prompt
     /attach clipboard       Attach image copied to macOS/Windows clipboard
     /exit                   Exit the REPL
@@ -302,8 +377,8 @@ async function main() {
     ANTHROPIC_API_KEY       Direct Anthropic API key
     OPENROUTER_API_KEY      OpenRouter API key
     BAHULAM_CONFIG_DIR        Override config directory (default: ~/.bahulam)
-    KEPLER_CONFIG_DIR         Legacy config directory override
-    KEPLER_RECONNECT_MAX_ELAPSED_MS
+    BAHULAM_CONFIG_DIR         Legacy config directory override
+    BAHULAM_RECONNECT_MAX_ELAPSED_MS
                             Max reconnect window for dropped streams
     BAHULAM_TTY_MODE=stable Scrollback-safe transcript if fixed dock redraws leak
     BAHULAM_BLOCK_SEPARATOR Tool/content separator: space, dotted, or off
@@ -407,7 +482,9 @@ async function main() {
   const daemonSpawned = process.env.BAHULAM_DAEMON_SPAWNED === '1';
   const daemonPrompt = daemonSpawned ? (process.env.BAHULAM_DAEMON_INITIAL_PROMPT || '').trim() : '';
   const effectivePrompt = args.prompt || (daemonSpawned && daemonPrompt) || '';
-  if (effectivePrompt && (daemonSpawned || process.argv.includes('--headless') || !process.stdin.isTTY)) {
+  const hasGraphTarget = Boolean(args.agent || args.workflow);
+  if ((effectivePrompt || hasGraphTarget)
+      && (daemonSpawned || process.argv.includes('--headless') || !process.stdin.isTTY || hasGraphTarget)) {
     const { runHeadless } = await import('../core/headless.mjs');
     await runHeadless({
       instruction: effectivePrompt,
@@ -417,6 +494,8 @@ async function main() {
       cacheReport: args.cacheReport,
       local: args.local,
       vision: args.vision,
+      agent: args.agent,
+      workflow: args.workflow,
     });
     return;
   }

package/src/terminal/repl-explore.mjs

@@ -25,7 +25,7 @@ const EXPLORE_TOOL_CATEGORY = new Map([
 ]);
 
 export function exploreCollapseEnabled() {
-  return process.env.KEPLER_EXPLORE_COLLAPSE !== '0';
+  return process.env.BAHULAM_EXPLORE_COLLAPSE !== '0';
 }
 
 export function isExploreTool(tool) {

package/src/terminal/repl-render.mjs

@@ -34,8 +34,8 @@ import * as queue from '../ui/render-queue.mjs';
 // queue active) → coalesced last-wins status that can never interleave
 // with content. Legacy dock path and bare-TTY inPlace stay as fallbacks
 // until their write-sites migrate onto the queue too.
-// Max inner-tool lines shown under the spinner during a sub-agent run.
-const SUB_AGENT_WINDOW_ROWS = 7;
+// Max live-window lines under the spinner during a sub-agent run.
+const SUB_AGENT_WINDOW_ROWS = 8;
 
 function statusWidth() {
   return Math.max(8, (process.stderr.columns || process.stdout.columns || 120) - 1);
@@ -49,6 +49,18 @@ function fitStatusLines(lines) {
   return (Array.isArray(lines) ? lines : [lines]).map(fitStatusLine);
 }
 
+function subAgentWindowLines(win) {
+  if (win?.groups instanceof Map && win.groups.size) {
+    const lines = [];
+    for (const group of win.groups.values()) {
+      if (group?.header) lines.push(group.header);
+      for (const line of group?.lines || []) lines.push(line);
+    }
+    return lines;
+  }
+  return (win?.lines || []).slice(-SUB_AGENT_WINDOW_ROWS);
+}
+
 function presentStatus(rendered) {
   // Watch panel override: when active, render the watch panel entries as a
   // multi-line status block instead of the normal spinner/status line.
@@ -69,10 +81,11 @@ function presentStatus(rendered) {
   const fitted = fitStatusLine(rendered);
   if (queue.isActive()) {
     const win = runtime.subAgentWindow;
-    if (win?.active && win.lines.length) {
+    const subAgentLines = subAgentWindowLines(win);
+    if (win?.active && subAgentLines.length) {
       queue.statusBlock([
         fitted,
-        ...fitStatusLines(win.lines.slice(-SUB_AGENT_WINDOW_ROWS).map(l => `    ${c.dim(l)}`)),
+        ...fitStatusLines(subAgentLines.map(l => `    ${c.dim(l)}`)),
       ]);
       return;
     }
@@ -95,7 +108,7 @@ export function pushSubAgentWindowLine(line) {
 }
 
 export function setSubAgentWindowActive(active) {
-  runtime.subAgentWindow = { active: Boolean(active), lines: [] };
+  runtime.subAgentWindow = { active: Boolean(active), lines: [], groups: new Map() };
 }
 
 /**
@@ -109,6 +122,25 @@ export function rebuildSubAgentWindow(lines) {
   const win = runtime.subAgentWindow;
   if (!win?.active) return;
   win.lines = Array.isArray(lines) ? lines.slice() : [];
+  win.groups = new Map();
+  repaintSpinnerStatus();
+}
+
+export function rebuildSubAgentWindowGroups(groups) {
+  const win = runtime.subAgentWindow;
+  if (!win?.active) return;
+  win.groups = new Map();
+  win.lines = [];
+  for (const group of Array.isArray(groups) ? groups : []) {
+    const key = group?.runId || group?.key || group?.label;
+    if (!key) continue;
+    win.groups.set(key, {
+      runId: group.runId || null,
+      label: group.label || 'sub-agent',
+      header: group.header || group.label || 'sub-agent',
+      lines: Array.isArray(group.lines) ? group.lines.slice() : [],
+    });
+  }
   repaintSpinnerStatus();
 }
 
@@ -211,12 +243,12 @@ function exploreRunTotal() {
 }
 
 function exploreSnapshotEvery() {
-  const n = Number.parseInt(process.env.KEPLER_EXPLORE_SNAPSHOT_EVERY || '8', 10);
+  const n = Number.parseInt(process.env.BAHULAM_EXPLORE_SNAPSHOT_EVERY || '8', 10);
   return Number.isFinite(n) ? Math.max(1, n) : 8;
 }
 
 function exploreSnapshotMs() {
-  const n = Number.parseInt(process.env.KEPLER_EXPLORE_SNAPSHOT_MS || '900', 10);
+  const n = Number.parseInt(process.env.BAHULAM_EXPLORE_SNAPSHOT_MS || '900', 10);
   return Number.isFinite(n) ? Math.max(100, n) : 900;
 }
 
@@ -308,11 +340,27 @@ export function renderToolCall(data) {
   const args = data?.args || {};
   const indent = subAgentIndent();
   const callId = data?.call_id || data?._callId || `${tool}:${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const fromSubAgent = Boolean(data?.internal || data?.sub_agent || data?.sub_agent_label || data?.sub_agent_run_id);
 
   // If a previous head is still pending (no result yet), flush it as a
   // regular two-line shape before starting the next one.
   flushPendingHead();
 
+  // Sub-agent live window (queue mode): inner tool calls stream into the
+  // fixed-height status block instead of appending transcript lines. Keep
+  // this ahead of explore-collapse so parallel explores do not merge into
+  // one global read/search spinner.
+  if (fromSubAgent && queue.isActive() && runtime.subAgentWindow?.active) {
+    recordCard({ id: callId, tool, args, startedAt: Date.now() });
+    session.toolCounts[tool] = (session.toolCounts[tool] || 0) + 1;
+    const label = readToolLabel(tool, { args });
+    const runId = data?.run_id || data?.sub_agent_run_id || '';
+    const runSuffix = runId ? ` run ${String(runId).slice(0, 8)}` : '';
+    const lane = data?.sub_agent_label ? `[${data.sub_agent_label}${runSuffix}] ` : '';
+    pushSubAgentWindowLine(label ? `${lane}→ ${tool} · ${label}` : `${lane}→ ${tool}`);
+    return; // the spinner tick paints the window block
+  }
+
   // ── Explore-run collapse ────────────────────────────────────────────────
   // For list/read/search/index tools, skip the per-call head entirely and
   // update a single animated summary spinner. The transcript stays clean;
@@ -328,9 +376,8 @@ export function renderToolCall(data) {
     return;
   }
 
-  // Sub-agent live window (queue mode): inner tool calls stream into the
-  // fixed-height status block instead of appending transcript lines. The
-  // card is still recorded so /expand, /last, and `d` show full detail.
+  // Legacy sub-agent live window fallback for events without explicit
+  // sub-agent metadata.
   if (queue.isActive() && runtime.subAgentWindow?.active && inSubAgentBlock()) {
     recordCard({ id: callId, tool, args, startedAt: Date.now() });
     session.toolCounts[tool] = (session.toolCounts[tool] || 0) + 1;
@@ -410,6 +457,14 @@ export function renderToolResult(data, eventType = 'tool_result') {
     indent: gutter,
     columns: process.stderr.columns || 120,
   });
+  const fromSubAgent = Boolean(data?.internal || data?.sub_agent || data?.sub_agent_label || data?.sub_agent_run_id);
+
+  // Sub-agent live window: the call line is already streaming in the
+  // status block; the result stays card-only (close card summarizes). This
+  // must run before explore-collapse for read/search tools used by explores.
+  if (fromSubAgent && queue.isActive() && runtime.subAgentWindow?.active) {
+    return;
+  }
 
   // Explore tools: the call already updated the summary spinner. Refresh
   // the "latest" hint with the result's file if we have one, and skip the
@@ -421,8 +476,8 @@ export function renderToolResult(data, eventType = 'tool_result') {
     return;
   }
 
-  // Sub-agent live window: the call line is already streaming in the
-  // status block; the result stays card-only (close card summarizes).
+  // Legacy sub-agent live window fallback for events without explicit
+  // sub-agent metadata.
   if (queue.isActive() && runtime.subAgentWindow?.active && inSubAgentBlock()) {
     return;
   }

package/src/terminal/repl-state.mjs

@@ -43,7 +43,8 @@ export const runtime = {
 
   // Explore-run collapse (read/list/search/index bursts as concise progress).
   exploreRun: { counts: {}, recent: [], lineActive: false, lastPrintedSummary: '', lastPrintedTotal: 0, lastPrintedAt: 0 },
-  foldedSubAgentTools: null, // { agentType, entries, startedAt } for default/quiet folded sub-agent tools
+  foldedSubAgentTools: null, // current folded sub-agent tool bucket
+  foldedSubAgentToolMap: new Map(), // run-aware buckets for parallel sub-agents
 
   // Animated spinner state (single shared interval; text/frame drive inPlace).
   spinInterval: null,
@@ -61,7 +62,7 @@ export const runtime = {
   // its inner tool calls stream into a fixed-height status block (last
   // N lines under the spinner) instead of appending to the transcript.
   // Full detail stays on the recorded cards (/expand, /last, `d`).
-  subAgentWindow: { active: false, lines: [] },
+  subAgentWindow: { active: false, lines: [], groups: new Map() },
 
   // PRD-092: Watch panel — toggled by /watch. When active, the spinner
   // area renders a compact agent-activity summary instead of the spinner.
@@ -106,6 +107,7 @@ export const session = {
   lastTurnDuration: 0,
   toolCounts: {},      // per-tool histogram (mission report)
   subAgentCounts: {},  // per-sub-agent histogram (mission report)
+  activeSubAgentRuns: new Map(), // run_id -> active sub-agent lane
   savedUsd: 0,         // total sub-agent cost (for "saved by routing")
   lastTask: '',        // most recent user prompt (mission report title)
   lastReasoning: '',   // captured from agent for /why