@bahulam/code 2.6.13 → 2.6.15

package/src/terminal/agents.mjs

@@ -10,9 +10,8 @@
  * - architect: Feature architect — designs implementations, file plans
  */
 
-import { c, spinner, inPlace, hr } from './ansi.mjs';
+import { c } from './ansi.mjs';
 import { TarangStreamClient } from '../core/stream-client.mjs';
-import { resolveBackendUrl } from '../core/backend-url.mjs';
 
 // ── Agent Definitions ────────────────────────────────────────
 
@@ -105,20 +104,172 @@ Rules:
 
 // ── Agent Runner ─────────────────────────────────────────────
 
+const TOOL_ALIASES = new Map([
+  ['bash', 'shell'],
+  ['shell_command', 'shell'],
+  ['read', 'read_file'],
+  ['write', 'write_file'],
+  ['edit', 'edit_file'],
+  ['grep', 'search_code'],
+]);
+
+function canonicalToolName(value) {
+  const key = String(value || '').trim().toLowerCase();
+  return TOOL_ALIASES.get(key) || key;
+}
+
+const RUNTIME_PLACEHOLDER_CWDS = new Set([
+  '/workspace',
+  '/workspace/kepler-code',
+]);
+
+function normalizeScopedArgs(toolName, args = {}, { projectRoot = null } = {}) {
+  if (canonicalToolName(toolName) !== 'shell' || !projectRoot) return args;
+  const next = { ...(args || {}) };
+  const cwd = String(next.cwd || '').trim();
+  if (!cwd || RUNTIME_PLACEHOLDER_CWDS.has(cwd)) {
+    next.cwd = projectRoot;
+  }
+  return next;
+}
+
+function createScopedToolExecutor(baseExecutor, agent, { projectRoot = null } = {}) {
+  const tools = Array.isArray(agent.tools) ? agent.tools : [];
+  const allowed = new Set(tools.map(canonicalToolName).filter(Boolean));
+  if (!allowed.size) return baseExecutor;
+
+  return {
+    ...baseExecutor,
+    execute: async (toolName, args = {}, options = {}) => {
+      const canonical = canonicalToolName(toolName);
+      if (!allowed.has(canonical)) {
+        return {
+          success: false,
+          output: `Tool '${toolName}' is not allowed for agent '${agent.name}'. Allowed tools: ${tools.join(', ')}`,
+        };
+      }
+      return baseExecutor.execute.call(
+        baseExecutor,
+        toolName,
+        normalizeScopedArgs(toolName, args, { projectRoot }),
+        options,
+      );
+    },
+  };
+}
+
+export function findBuiltinAgent(agentName) {
+  const target = String(agentName || '').trim().toLowerCase();
+  return BUILTIN_AGENTS.find(agent => agent.command === target || agent.name.toLowerCase() === target) || null;
+}
+
+export function localAgentMatches(agent, target) {
+  const needle = String(target || '').trim().toLowerCase();
+  if (!needle) return false;
+  return [
+    agent.slug,
+    agent.id,
+    agent.name,
+  ].some(value => String(value || '').trim().toLowerCase() === needle);
+}
+
+function normalizeRunnableAgent(agent) {
+  const spec = agent?.spec || {};
+  const config = agent?.config || spec.config || agent?.raw_config || {};
+  const configAgent = config.agent || {};
+  const tools = Array.isArray(agent?.tools)
+    ? agent.tools
+    : Array.isArray(spec.tools)
+      ? spec.tools
+      : Array.isArray(config.tools)
+        ? config.tools
+        : [];
+
+  const name = agent?.name || spec.name || agent?.slug || agent?.command || 'agent';
+  return {
+    command: agent?.command || agent?.slug || spec.slug || name,
+    slug: agent?.slug || spec.slug || agent?.command || name,
+    name,
+    description: agent?.description || spec.description || '',
+    role: agent?.role || spec.role || 'specialist',
+    icon: agent?.icon || '◇',
+    systemPrompt: agent?.systemPrompt || agent?.system_prompt || agent?.prompt || spec.system_prompt || configAgent.system_prompt || '',
+    readOnly: Boolean(agent?.readOnly),
+    model: agent?.model || spec.model || configAgent.model || null,
+    models: agent?.models || spec.models || configAgent.models || null,
+    tools,
+    source: agent?.source || spec.source || '',
+  };
+}
+
+function agentInstructionPrefix(agent, execContext = {}) {
+  const lines = [];
+  if (agent.systemPrompt) {
+    lines.push(agent.systemPrompt);
+  } else {
+    lines.push(`You are ${agent.name}, a Bahulam Code sub-agent.`);
+  }
+  if (agent.description) lines.push(`\nAgent description: ${agent.description}`);
+  if (agent.role) lines.push(`Agent role: ${agent.role}`);
+  if (agent.tools.length) {
+    lines.push(
+      `Allowed tools for this sub-agent: ${agent.tools.join(', ')}. ` +
+      'Do not request tools outside this list.',
+    );
+  }
+  if (execContext.project_root) {
+    lines.push(`Runtime project root: ${execContext.project_root}. Use this as the cwd for shell commands unless the task explicitly requires a different registered project root.`);
+  }
+  return lines.join('\n');
+}
+
+function displayEventForDirectAgent(event, agent) {
+  if (!event || !event.type) return event;
+  if (!['tool_call', 'tool_request', 'tool_result', 'tool_done', 'sub_agent_tool'].includes(event.type)) {
+    return event;
+  }
+  return {
+    ...event,
+    data: {
+      ...(event.data || {}),
+      internal: true,
+      sub_agent: event.data?.sub_agent || agent.slug || agent.command || agent.name || 'agent',
+    },
+  };
+}
+
 /**
- * Run a built-in agent with the given instruction.
- * @param {string} agentName - e.g. 'explore', 'review', 'architect'
+ * Run a normalized agent definition with the given instruction.
+ * @param {Object} agentDefinition - Built-in or .bahulam/agents definition
  * @param {string} instruction - User's instruction
  * @param {Object} ctx - { auth, toolExecutor, approval }
  * @param {Object} session - Session state
  * @param {Function} renderEvent - Event renderer function
+ * @param {Object} [options]
  */
-export async function runAgent(agentName, instruction, ctx, session, renderEvent) {
-  const agent = BUILTIN_AGENTS.find(a => a.command === agentName);
-  if (!agent) {
-    process.stderr.write(`  ${c.red('Unknown agent: ' + agentName)}\n`);
-    return;
-  }
+export async function runAgentDefinition(agentDefinition, instruction, ctx, session, renderEvent, options = {}) {
+  const agent = normalizeRunnableAgent(agentDefinition);
+  const userInstruction = String(instruction || '').trim() || 'Run your assigned task now.';
+  const suppliedContext = options.execContext || options.context || {};
+  const baseCwd = suppliedContext.cwd || options.cwd || process.cwd();
+  const suppliedSubAgent = suppliedContext.sub_agent && typeof suppliedContext.sub_agent === 'object'
+    ? suppliedContext.sub_agent
+    : {};
+  const projectRoot = suppliedContext.project_root || null;
+  const execContext = {
+    ...suppliedContext,
+    cwd: suppliedContext.cwd || baseCwd,
+    ...(projectRoot ? { project_root: projectRoot } : {}),
+    sub_agent: {
+      ...suppliedSubAgent,
+      name: agent.name,
+      slug: agent.slug,
+      role: agent.role,
+      description: agent.description,
+      tools: agent.tools,
+      source: agent.source,
+    },
+  };
 
   const creds = ctx.auth.loadCredentials();
   if (!creds.token) {
@@ -129,49 +280,74 @@ export async function runAgent(agentName, instruction, ctx, session, renderEvent
   // Header
   process.stderr.write(`\n  ${agent.icon} ${c.bold(c.brand(agent.name))}\n`);
   process.stderr.write(`  ${c.gray('─'.repeat(40))}\n`);
-  process.stderr.write(`  ${c.gray(instruction)}\n\n`);
+  if (agent.description) process.stderr.write(`  ${c.gray(agent.description)}\n`);
+  if (agent.source) process.stderr.write(`  ${c.dim(agent.source)}\n`);
+  process.stderr.write(`  ${c.gray(userInstruction)}\n\n`);
 
   // Prepend agent system prompt to instruction
-  const fullInstruction = `${agent.systemPrompt}\n\n---\n\nUser request: ${instruction}`;
+  const fullInstruction = `${agentInstructionPrefix(agent, execContext)}\n\n---\n\nUser request: ${userInstruction}`;
 
   // For read-only agents, use a restricted approval manager
   const { ApprovalManager } = await import('../core/approval.mjs');
   const agentApproval = agent.readOnly
     ? new ApprovalManager({ planMode: true })  // planMode blocks all writes
     : ctx.approval;
+  const toolExecutor = createScopedToolExecutor(ctx.toolExecutor, agent, {
+    projectRoot: execContext.project_root || null,
+  });
 
   const client = new TarangStreamClient({
     baseUrl: creds.backendUrl,
     token: creds.token,
-    toolExecutor: ctx.toolExecutor,
+    toolExecutor,
     approvalManager: agentApproval,
   });
 
   session.turns++;
   session.toolCalls = 0;
   let assistantContent = '';
+  if (agent.model) execContext.model_override = agent.model;
+  if (agent.models && typeof agent.models === 'object' && Object.keys(agent.models).length) {
+    execContext.model_overrides = agent.models;
+  }
 
   try {
-    for await (const event of client.execute(fullInstruction, { cwd: process.cwd() })) {
-      renderEvent(event);
+    for await (const event of client.execute(fullInstruction, execContext)) {
+      renderEvent(displayEventForDirectAgent(event, agent));
 
       if (event.type === 'content' || event.type === 'content_partial') {
         const text = event.data?.text || '';
-        if (text) assistantContent = text;
+        if (text) assistantContent += text;
       }
     }
   } catch (err) {
-    inPlace('');
     process.stderr.write(`  ${c.red('Agent error: ' + err.message)}\n`);
   }
 
   // Save to conversation history
   if (assistantContent) {
     session.history.push(
-      { role: 'user', content: `[${agent.name}] ${instruction}` },
+      { role: 'user', content: `[${agent.name}] ${userInstruction}` },
       { role: 'assistant', content: assistantContent }
     );
   }
 
   process.stderr.write('\n');
 }
+
+/**
+ * Run a built-in agent with the given instruction.
+ * @param {string} agentName - e.g. 'explore', 'review', 'architect'
+ * @param {string} instruction - User's instruction
+ * @param {Object} ctx - { auth, toolExecutor, approval }
+ * @param {Object} session - Session state
+ * @param {Function} renderEvent - Event renderer function
+ */
+export async function runAgent(agentName, instruction, ctx, session, renderEvent) {
+  const agent = findBuiltinAgent(agentName);
+  if (!agent) {
+    process.stderr.write(`  ${c.red('Unknown agent: ' + agentName)}\n`);
+    return;
+  }
+  return runAgentDefinition(agent, instruction, ctx, session, renderEvent);
+}

package/src/terminal/repl-render.mjs

@@ -9,7 +9,7 @@
  *   - Content streaming (SSE partials → debounced markdown flush)
  *   - Spinner (single animated line, shared across concerns)
  *   - Stagnation banner
- *   - Detail expansion (/last, /expand N, Ctrl+D)
+ *   - Detail expansion (/last, /expand N, F2)
  *
  * All mutable state lives in repl-state.mjs (`runtime`). Consumers of this
  * module (renderEvent, handleCommand, keypress handlers) import the specific
@@ -22,6 +22,8 @@ import { runtime, session } from './repl-state.mjs';
 import { fitAnsiLine } from './repl-format.mjs';
 import { exploreCategory, isExploreTool } from './repl-explore.mjs';
 import {
+  clearPinnedStatus,
+  drawPinnedStatus,
   isInputDockMounted,
   moveToContent,
 } from '../ui/input-dock.mjs';
@@ -277,6 +279,7 @@ export function renderToolResult(data, eventType = 'tool_result') {
   const tool = data.tool || data._tool || '';
   const durationMs = data?.duration_ms ?? (data?.duration_s != null ? data.duration_s * 1000 : null);
   recordReadActivity(tool, data.args || {});
+  recordWriteActivity(tool, data.args || {}, data);
 
   // Update the card buffer so /last and `d` can find it.
   if (callId) recordCard({ id: callId, tool, args: data.args, result: data, durationMs });
@@ -285,7 +288,9 @@ export function renderToolResult(data, eventType = 'tool_result') {
 
   const { text, tone: t } = summarizeResult(tool, data);
   // Em dash reads more like prose than a system arrow.
-  const arrow = paint.text.dim('—');
+  const arrow = shellResultTool(tool)
+    ? `${paint.text.dim('result')} ${paint.text.dim('—')}`
+    : paint.text.dim('—');
   const painter = t === 'success' ? paint.state.success
                 : t === 'warn'    ? paint.state.warn
                 : t === 'danger'  ? paint.state.danger
@@ -320,7 +325,10 @@ export function renderToolResult(data, eventType = 'tool_result') {
     const combined = `${runtime.pendingHead.head}  ${outcome}`;
     if (stripAnsi(combined).length <= cols) {
       process.stderr.write(`${combined}\n`);
-      if (diffPreview) process.stderr.write(`${diffPreview}\n`);
+      if (diffPreview) {
+        process.stderr.write(`${diffPreview}\n`);
+        rememberFileDiffPreview(data);
+      }
       runtime.lastRenderedBlock = 'tool';
       runtime.pendingHead = null;
       return;
@@ -328,7 +336,10 @@ export function renderToolResult(data, eventType = 'tool_result') {
     if (isInlineOutcomeTool(tool)) {
       const compactHead = compactHeadForOutcome(runtime.pendingHead.head, outcome, cols);
       process.stderr.write(`${compactHead}  ${outcome}\n`);
-      if (diffPreview) process.stderr.write(`${diffPreview}\n`);
+      if (diffPreview) {
+        process.stderr.write(`${diffPreview}\n`);
+        rememberFileDiffPreview(data);
+      }
       runtime.lastRenderedBlock = 'tool';
       runtime.pendingHead = null;
       return;
@@ -343,7 +354,10 @@ export function renderToolResult(data, eventType = 'tool_result') {
 
   // Two-line shape: gutter under the (already-printed or just-flushed) head.
   process.stderr.write(`${gutter}${outcome}\n`);
-  if (diffPreview) process.stderr.write(`${diffPreview}\n`);
+  if (diffPreview) {
+    process.stderr.write(`${diffPreview}\n`);
+    rememberFileDiffPreview(data);
+  }
   runtime.lastRenderedBlock = 'tool';
 
   // Lint warnings stay visible alongside writes.
@@ -352,6 +366,65 @@ export function renderToolResult(data, eventType = 'tool_result') {
   }
 }
 
+function fileDiffKey(data = {}) {
+  return fileDiffKeys(data)[0] || '';
+}
+
+function fileDiffKeys(data = {}) {
+  const keys = [];
+  const callId = data.call_id || data._callId || data.request_id || data.id;
+  if (callId) keys.push(`call:${callId}`);
+  const diff = Array.isArray(data.file_diffs) ? data.file_diffs[0]
+    : data.file_diff ? data.file_diff
+    : data.type === 'file_diff' ? data
+    : null;
+  const file = diff?.relative_path || diff?.path || data.relative_path || data.path || '';
+  if (file) {
+    const added = diff?.lines_added ?? data.lines_added ?? '';
+    const removed = diff?.lines_removed ?? data.lines_removed ?? '';
+    keys.push(`file:${file}:${added}:${removed}`);
+  }
+  return keys;
+}
+
+function rememberFileDiffPreview(data = {}) {
+  for (const key of fileDiffKeys(data)) {
+    runtime.renderedFileDiffPreviews.add(key);
+  }
+}
+
+export function renderFileDiffEvent(data = {}) {
+  const keys = fileDiffKeys(data);
+  if (keys.some(key => runtime.renderedFileDiffPreviews.has(key))) return false;
+
+  const indent = subAgentIndent();
+  const gutter = `${indent}${paint.text.dim('⎿')}  `;
+  const diffPreview = formatCompactFileDiff({
+    file_diff: data,
+    lines_added: data.lines_added,
+    lines_removed: data.lines_removed,
+  }, {
+    indent: gutter,
+    columns: process.stderr.columns || 120,
+    showFileHeader: true,
+  });
+  if (!diffPreview) return false;
+
+  renderBlockBoundary('tool', { compactSame: true });
+  process.stderr.write(`${diffPreview}\n`);
+  for (const key of keys) runtime.renderedFileDiffPreviews.add(key);
+  rememberChangedFile(data.relative_path || data.path);
+  runtime.lastRenderedBlock = 'tool';
+  return true;
+}
+
+function shellResultTool(tool) {
+  return [
+    'shell', 'run_tests', 'validate_build', 'lint_check',
+    'validate_file', 'validate_structure',
+  ].includes(String(tool || '').toLowerCase());
+}
+
 // ── Expand handler — `d`, `/last`, `/expand` ───────────────────────────
 //
 // All three call into the same renderer so output is consistent across
@@ -404,6 +477,11 @@ export function rememberReadFile(filePath) {
   if (file && !session.filesRead.includes(file)) session.filesRead.push(file);
 }
 
+export function rememberChangedFile(filePath) {
+  const file = shortPath(String(filePath || '').trim());
+  if (file && !session.filesChanged.includes(file)) session.filesChanged.push(file);
+}
+
 export function recordReadActivity(tool, args = {}) {
   const normalized = String(tool || '').toLowerCase();
   if (normalized === 'read_file' || normalized === 'read') {
@@ -418,6 +496,26 @@ export function recordReadActivity(tool, args = {}) {
   }
 }
 
+export function recordWriteActivity(tool, args = {}, result = {}) {
+  const normalized = String(tool || '').toLowerCase();
+  if (!['write_file', 'edit_file', 'delete_file', 'write_project'].includes(normalized)) return;
+
+  if (normalized === 'write_project') {
+    const files = Array.isArray(args.files) ? args.files : [];
+    for (const file of files) {
+      rememberChangedFile(file?.file_path || file?.path);
+    }
+  }
+
+  rememberChangedFile(args.file_path || args.path || result.file_path || result.path);
+  const diffs = Array.isArray(result.file_diffs)
+    ? result.file_diffs
+    : result.file_diff ? [result.file_diff] : [];
+  for (const diff of diffs) {
+    rememberChangedFile(diff.relative_path || diff.path);
+  }
+}
+
 export function thinkingKind(text) {
   return /\b(read|reading|inspect|scan|search|open|trace|look(?:ing)?\s+at)\b/i.test(text)
     ? 'Reading'
@@ -461,7 +559,10 @@ export function startSpinner(text) {
     if (isExploreActive && isInputDockMounted()) {
       return;
     }
-    if (isInputDockMounted()) moveToContent();
+    if (isInputDockMounted()) {
+      drawPinnedStatus(rendered);
+      return;
+    }
     inPlace(rendered);
   }, 80);
 }
@@ -477,7 +578,11 @@ export function stopSpinner() {
   if (runtime.exploreRun && runtime.exploreRun.lineActive) return;
   if (runtime.spinInterval) { clearInterval(runtime.spinInterval); runtime.spinInterval = null; }
   runtime.spinText = '';
-  if (isInputDockMounted()) moveToContent();
+  if (isInputDockMounted()) {
+    clearPinnedStatus();
+    moveToContent();
+    return;
+  }
   inPlace('');
 }
 
@@ -493,6 +598,7 @@ export function startContentStream() {
   runtime.streamBuffer = '';
   runtime.streamedPartialText = '';
   runtime.renderedToolResults.clear();
+  runtime.renderedFileDiffPreviews.clear();
   runtime.exploreRun = { counts: {}, recent: [], lineActive: false, lastPrintedSummary: '', lastPrintedTotal: 0, lastPrintedAt: 0 };
   runtime.renderedContentThisTurn = false;
   runtime.contentHeaderPrinted = false;
@@ -517,27 +623,36 @@ export function flushContent() {
   if (runtime.streamTimer) { clearTimeout(runtime.streamTimer); runtime.streamTimer = null; }
   if (!runtime.streamBuffer) return;
 
+  const rendered = renderMarkdown(runtime.streamBuffer);
+  const lines = transcriptRenderableLines(rendered);
+  runtime.streamBuffer = '';
+  if (!lines.length) return;
+
   if (isInputDockMounted()) moveToContent();
   stopSpinner();
   // Any buffered tool head needs to land BEFORE this content so the order
   // is preserved on screen.
   flushPendingHead();
   flushCompactReadRun();
-  renderBlockBoundary('content');
+  renderBlockBoundary('content', { compactSame: true });
   if (!runtime.contentHeaderPrinted) {
     process.stdout.write(`${transcriptHeader('bahulam', { tone: 'assistant' })}\n`);
     runtime.contentHeaderPrinted = true;
   }
-  const rendered = renderMarkdown(runtime.streamBuffer);
-  for (const line of rendered.split('\n')) {
+  for (const line of lines) {
     process.stdout.write(`${transcriptLine(line, { tone: 'assistant' })}\n`);
   }
-  runtime.streamBuffer = '';
   runtime.renderedContentThisTurn = true;
   runtime.lastRenderedBlock = 'content';
   if (typeof runtime.afterContentFlush === 'function') runtime.afterContentFlush();
 }
 
+export function transcriptRenderableLines(rendered) {
+  const lines = String(rendered ?? '').replace(/\r\n?/g, '\n').split('\n');
+  while (lines.length && lines[lines.length - 1] === '') lines.pop();
+  return lines;
+}
+
 export function renderStagnation(data = {}) {
   const rawMessage = data?.message || '';
   const reason = data?.reason || rawMessage.replace(/^Stagnation:\s*/i, '').trim();

package/src/terminal/repl-state.mjs

@@ -39,9 +39,11 @@ export const runtime = {
   pendingHead: null,          // { callId, head, indent } buffered until result arrives
   lastRenderedBlock: null,    // 'tool' | 'content' | 'thinking' | 'status' | 'plan' | null
   renderedToolResults: new Set(),
+  renderedFileDiffPreviews: new Set(),
 
   // 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
 
   // Animated spinner state (single shared interval; text/frame drive inPlace).
   spinInterval: null,