@bahulam/code 0.1.11 → 0.1.13

package/src/tools/agent.mjs

@@ -58,9 +58,13 @@ export const AgentTool = {
     _backgroundAgents: new Map(),
     _nextBgId: 0,
 
-    async call(input) {
+    async call(input, options = {}) {
         const model = input.model || process.env.SUBAGENT_MODEL || 'claude-sonnet-4-6';
-        const tools = createToolRegistry();
+        const tools = createToolRegistry({
+            pluginRegistry: options.pluginRegistry || null,
+            stateEmit: options.stateEmit || null,
+            exposePluginTools: true,
+        });
         const permissions = createPermissionChecker({ defaultMode: 'bypassPermissions' });
 
         // Build type-specific system prompt prefix

package/src/tools/registry.mjs

@@ -39,6 +39,7 @@ import { ExploreTool, PlanTool, VerifyTool, DebugTool, RefactorTool } from './me
 import { RememberTool } from './remember.mjs';
 import { GenerateImageTool } from './generate-image.mjs';
 import { AnalyzeImageTool } from './analyze-image.mjs';
+import { loadPluginTool } from '../plugins/executor.mjs';
 
 const BUILTIN_TOOLS = [
     BashTool,
@@ -82,12 +83,114 @@ const BUILTIN_TOOLS = [
     RefactorTool,
 ];
 
-export function createToolRegistry() {
+export function createToolRegistry({
+    pluginRegistry = null,
+    stateEmit = null,
+    exposePluginTools = false,
+} = {}) {
     const tools = new Map();
     for (const Tool of BUILTIN_TOOLS) {
-        tools.set(Tool.name, Tool);
+        if (Tool === AgentTool) {
+            tools.set(Tool.name, {
+                ...Tool,
+                async call(input, options = {}) {
+                    return Tool.call(input, {
+                        ...options,
+                        pluginRegistry: options.pluginRegistry || pluginRegistry,
+                        stateEmit: options.stateEmit || stateEmit,
+                    });
+                },
+            });
+        } else {
+            tools.set(Tool.name, Tool);
+        }
     }
 
+    const pluginStateHandles = new Map();
+    async function pluginStateFor(pluginName) {
+        if (!pluginName) return null;
+        if (pluginStateHandles.has(pluginName)) return pluginStateHandles.get(pluginName);
+        const { makePluginState } = await import('../plugins/state.mjs');
+        const state = makePluginState(pluginName, { emit: stateEmit });
+        pluginStateHandles.set(pluginName, state);
+        return state;
+    }
+
+    function registerPluginToolsFromRegistry() {
+        if (!pluginRegistry) return;
+        for (const toolDef of pluginRegistry.listTools?.() || []) {
+            const name = String(toolDef.name || '').trim();
+            if (!name || tools.has(name)) continue;
+            const pluginName = toolDef._plugin_name || toolDef.plugin_name || null;
+            if (toolDef._composed?.kind === 'pi') {
+                tools.set(name, {
+                    name,
+                    description: toolDef.description || '',
+                    inputSchema: toolDef.input_schema || toolDef.parameters || { type: 'object', properties: {} },
+                    validateInput() { return []; },
+                    async call() {
+                        return {
+                            success: false,
+                            output: `Composed pi tool '${name}' is registered but pi runtime execution is not wired yet`,
+                            _tool: name,
+                            _plugin: pluginName,
+                            _composed: toolDef._composed,
+                            _blocked: true,
+                        };
+                    },
+                });
+                continue;
+            }
+            tools.set(name, {
+                name,
+                description: toolDef.description || '',
+                inputSchema: toolDef.input_schema || toolDef.parameters || { type: 'object', properties: {} },
+                validateInput() { return []; },
+                async call(input, options = {}) {
+                    const handler = await loadPluginTool(toolDef._plugin_dir, toolDef.tool || toolDef.handler);
+                    if (!handler) {
+                        return {
+                            success: false,
+                            output: `Plugin tool module could not be loaded: ${name}`,
+                            _tool: name,
+                            _plugin: pluginName,
+                        };
+                    }
+                    const handlerOpts = {
+                        ...options,
+                        pluginName,
+                        get state() {
+                            if (this._stateP) return this._stateP;
+                            this._stateP = pluginStateFor(pluginName);
+                            return this._stateP;
+                        },
+                    };
+                    try {
+                        const result = await handler.call(input || {}, handlerOpts);
+                        if (result && typeof result === 'object' && 'success' in result) {
+                            return { ...result, _tool: name, _plugin: pluginName };
+                        }
+                        return {
+                            success: true,
+                            output: typeof result === 'string' ? result : JSON.stringify(result),
+                            _tool: name,
+                            _plugin: pluginName,
+                        };
+                    } catch (err) {
+                        return {
+                            success: false,
+                            output: `Plugin tool error (${name}): ${err.message}`,
+                            _tool: name,
+                            _plugin: pluginName,
+                        };
+                    }
+                },
+            });
+        }
+    }
+
+    if (exposePluginTools) registerPluginToolsFromRegistry();
+
     const registry = {
         list() {
             return [...tools.values()].map(t => ({
@@ -97,12 +200,12 @@ export function createToolRegistry() {
             }));
         },
 
-        async call(name, input) {
+        async call(name, input, options = {}) {
             const tool = tools.get(name);
             if (!tool) throw new Error(`Unknown tool: ${name}`);
             const errors = tool.validateInput?.(input) || [];
             if (errors.length > 0) return `Validation error: ${errors.join(', ')}`;
-            const result = await tool.call(input);
+            const result = await tool.call(input, options);
 
             return result;
         },

package/src/ui/input-dock.mjs

@@ -672,10 +672,13 @@ export function clearInputPrompt() {
   return true;
 }
 
-export function renderDockInput(prefix, value, { context = '', tips = '', meta = '', cursor = null } = {}) {
+export function renderDockInput(prefix, value, { context = '', tips = '', meta = '', cursor = null, fixedRows = null } = {}) {
   if (!mounted) return false;
   contentTrackingActive = false;
-  setInputRowsTo(computeInputRowsForBuffer(prefix, value));
+  const requestedRows = fixedRows == null
+    ? computeInputRowsForBuffer(prefix, value)
+    : Math.max(MIN_INPUT_ROWS, Math.min(inputRowsMax, Math.floor(Number(fixedRows) || MIN_INPUT_ROWS)));
+  setInputRowsTo(requestedRows);
   renderFrame({ context, tips, meta, prefix, value, cursor, overlayLines: null });
   const layout = layoutInput(prefix, value);
   drawInputLines(layout.lines);

package/src/ui/slash-commands.mjs

@@ -143,7 +143,7 @@ export const HELP_GROUPS = [
       ['/agents', 'List built-in and local agents'],
       ['/agents create <name>', 'Create .bahulam/agents/<name>.yaml'],
       ['/agents edit <name>', 'Open local agent YAML'],
-      ['/agents sync [name]', 'Sync all or one local agent to cloud'],
+      ['/agents sync [name]', 'Publish local agents to backend/account reuse'],
       ['/run <agent> [instruction]', 'Run a local or built-in agent'],
       ['/explore <instruction>', 'Explore code'],
       ['/review <instruction>', 'Review code'],

package/src/ui/sub-agent.mjs

@@ -70,11 +70,12 @@ export function displayQuery(query, max = 140) {
 
 export function renderSubAgentOpen({ id, type, query, parentDepth } = {}) {
   const t = type || 'sub-agent';
-  const depthBefore = _stack.length;
-  _stack.push({ id: id || `${t}-${depthBefore}-${tag()}`, type: t, startedAt: Date.now() });
+  const depthBefore = Number.isFinite(parentDepth) ? Math.max(0, parentDepth) : _stack.length;
+  _stack.push({ id: id || `${t}-${depthBefore}-${tag()}`, type: t, depth: depthBefore, startedAt: Date.now() });
 
   const indent = ' '.repeat(2 + depthBefore * 3);
-  const iconChar = SUB_ICONS[t] || icons.subAgent;
+  // Ordinal labels (explore#2) still get their base type's icon.
+  const iconChar = SUB_ICONS[t] || SUB_ICONS[String(t).replace(/#\d+$/, '')] || icons.subAgent;
   const shown = displayQuery(query);
   const head = `${indent}${iconChar} ${paint.brand.data(t)} ${paint.text.dim(`"${shown}"`)}`;
   const tag1 = paint.text.dim('▸ running');
@@ -95,6 +96,7 @@ export function renderSubAgentOpen({ id, type, query, parentDepth } = {}) {
  * and any of `{ costUsd, tokens, durationS, toolCalls, iterations }`.
  */
 export function renderSubAgentClose({
+  id,
   type,
   success = true,
   summary = '',
@@ -105,12 +107,16 @@ export function renderSubAgentClose({
   iterations,
   error,
 } = {}) {
-  // Match-pop: if the type doesn't match the top of stack we still pop the
-  // top entry — backends never emit interleaved open/close, so this is the
-  // safe behavior.
-  const opened = _stack.pop();
+  // Parallel sub-agents can complete out of stack order. Prefer exact id,
+  // then type, and fall back to the latest open entry for legacy streams.
+  let idx = -1;
+  if (id) idx = _stack.findLastIndex(entry => entry.id === id);
+  if (idx < 0 && type) idx = _stack.findLastIndex(entry => entry.type === type);
+  if (idx < 0) idx = _stack.length - 1;
+  const opened = idx >= 0 ? _stack.splice(idx, 1)[0] : null;
   const t = type || opened?.type || 'sub-agent';
-  const indent = ' '.repeat(2 + _stack.length * 3);
+  const closeDepth = Number.isFinite(opened?.depth) ? opened.depth : _stack.length;
+  const indent = ' '.repeat(2 + closeDepth * 3);
 
   if (!success) {
     const line = `${indent}${paint.text.dim('└')} ${paint.state.danger('✗')} ${paint.text.dim(`${t} agent failed`)}`;