@bahulam/code 0.1.6 → 0.1.8

package/src/terminal/tool-display.mjs

@@ -24,6 +24,8 @@ const TOOL_LABELS = Object.freeze({
   git_diff: 'Reviewing changes',
   git_status: 'Checking git',
   analyze_code: 'Analyzing',
+  analyze_image: 'Analyzing image',
+  generate_image: 'Generating image',
   get_project_overview: 'Indexing project',
   skills_list: 'Listing skills',
   skill_view: 'Loading skill',
@@ -76,9 +78,39 @@ function currentWorkingDirectory() {
   }
 }
 
+// Shortens a path for tool-card display without dropping the meaningful
+// tail. Strategy, in priority order:
+//
+//   1. INSIDE cwd            /repo/foo/bar.py  (cwd = /repo)     → foo/bar.py
+//   2. SIBLING under cwd's   /work/repo-a/x.py (cwd = /work/repo-b)
+//      parent                                                    → …/repo-a/x.py
+//                            (typical mono-repo / adjacent-clone case)
+//   3. UNDER $HOME           /Users/sree/Sites/…/x.py            → ~/Sites/…/x.py
+//   4. Absolute               (fallback — printed as-is; card truncator
+//                              handles the display width from here)
+//
+// The point: keep the basename + parent visible even when the full path
+// is long, so users don't see "Editing /Users/sree/Sites/.../
+// codekepler-ba…" with the actual filename lost off the right edge.
 function shortPath(filePath, cwd = currentWorkingDirectory()) {
   const value = String(filePath || '');
+  if (!value) return value;
+
+  // 1. inside cwd
   if (cwd && value.startsWith(`${cwd}/`)) return value.slice(cwd.length + 1);
+
+  // 2. sibling under cwd's parent (e.g. sister repo in the same workspace)
+  if (cwd) {
+    const cwdParent = cwd.slice(0, cwd.lastIndexOf('/'));
+    if (cwdParent && value.startsWith(`${cwdParent}/`)) {
+      return `…/${value.slice(cwdParent.length + 1)}`;
+    }
+  }
+
+  // 3. under $HOME
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  if (home && value.startsWith(`${home}/`)) return `~/${value.slice(home.length + 1)}`;
+
   return value;
 }
 

package/src/terminal/watch-state.mjs

@@ -0,0 +1,118 @@
+/**
+ * Watch panel — mutable state for the live agent activity tracker.
+ *
+ * Singleton exported as `watchState`. /watch toggles `active`, and
+ * renderEvent hooks push entries during the agent loop. Capped at
+ * MAX_ENTRIES to bound memory.
+ *
+ * Pattern: same as repl-state.mjs — exported mutable singleton.
+ */
+import { paint } from '../ui/palette.mjs';
+import { c } from './ansi.mjs';
+
+const MAX_ENTRIES = 80;
+
+/** @typedef {'spawn'|'activate'|'deactivate'|'handoff'|'tool'|'done'|'error'} EntryKind */
+
+/**
+ * @typedef {Object} WatchEntry
+ * @property {EntryKind} kind
+ * @property {string} id       — unique within the session
+ * @property {string} [type]   — agent type (explore, plan, etc.)
+ * @property {string} [label]  — display label (query, tool name, etc.)
+ * @property {number} [elapsed] — ms since entry was created
+ * @property {string} [detail] — extra info (model, tool count, error msg)
+ * @property {number} createdAt
+ * @property {'active'|'done'|'error'} [status]
+ */
+
+export const watchState = {
+  /** /watch toggle — when off, no entries are collected */
+  active: false,
+
+  /** Ordered list of watch entries, newest last */
+  entries: /** @type {WatchEntry[]} */ ([]),
+
+  /** Max visible rows in the panel (terminal rows reserved) */
+  maxRows: 6,
+
+  /** Turn-local counter for generating stable ids */
+  _seq: 0,
+
+  /** Add a new entry (prepends to front, pops if over MAX_ENTRIES) */
+  addEntry(kind, opts = {}) {
+    if (!this.active) return;
+    const id = opts.id || `w${++this._seq}`;
+    const entry = {
+      kind,
+      id,
+      type: opts.type || '',
+      label: opts.label || '',
+      elapsed: opts.elapsed || 0,
+      detail: opts.detail || '',
+      createdAt: Date.now(),
+      status: opts.status || 'active',
+    };
+    this.entries.push(entry);
+    if (this.entries.length > MAX_ENTRIES) {
+      this.entries.splice(0, this.entries.length - MAX_ENTRIES);
+    }
+  },
+
+  /** Update an entry by id (merge). */
+  updateEntry(id, patch) {
+    if (!this.active) return;
+    const entry = this.entries.find(e => e.id === id);
+    if (entry) Object.assign(entry, patch);
+  },
+
+  /** Remove entries that match a predicate. */
+  removeWhere(fn) {
+    if (!this.active) return;
+    this.entries = this.entries.filter(e => !fn(e));
+  },
+
+  clear() {
+    this.entries = [];
+    this._seq = 0;
+  },
+
+  /** Compact printable entries for the panel (newest last). */
+  visible(count = this.maxRows) {
+    const slice = this.entries.slice(-count);
+    return slice.map(e => renderEntryLine(e));
+  },
+};
+
+/** Format a single WatchEntry to an ANSI line. */
+function renderEntryLine(entry) {
+  const time = entry.elapsed
+    ? c.dim(` ${entry.elapsed < 1000 ? `${entry.elapsed}ms` : `${(entry.elapsed / 1000).toFixed(1)}s`}`)
+    : '';
+
+  switch (entry.kind) {
+    case 'spawn':
+      return `  ${c.green('+')} ${paint.text.dim(entry.type || 'agent')}${entry.label ? ` ${c.dim(entry.label)}` : ''}${time}`;
+
+    case 'activate':
+      return `  ${c.cyan('▸')} ${paint.text.dim(entry.type || 'agent')}${entry.label ? ` ${c.dim(entry.label)}` : ''}${time}`;
+
+    case 'deactivate':
+      return `  ${c.dim('✗')} ${paint.text.dim(entry.type || 'agent')}${entry.detail ? ` ${c.dim(entry.detail)}` : ''}`;
+
+    case 'handoff':
+      return `  ${c.yellow('↳')} ${paint.text.dim(entry.label || 'handoff')}${time}`;
+
+    case 'tool':
+      return `  ${paint.text.dim('·')} ${c.dim(entry.type || 'tool')}${entry.label ? ` ${c.dim(entry.label)}` : ''}${time}`;
+
+    case 'done':
+      return `  ${c.green('✓')} ${paint.text.dim(entry.type || 'agent')}${entry.detail ? ` ${c.dim(entry.detail)}` : ''}${time}`;
+
+    case 'error':
+      return `  ${c.red('✗')} ${paint.text.dim(entry.type || 'agent')}${entry.detail ? ` ${c.dim(entry.detail)}` : ''}`;
+
+    default:
+      return `  ${c.dim('·')} ${entry.label || ''}`;
+  }
+}

package/src/tools/agent.mjs

@@ -87,10 +87,10 @@ export const AgentTool = {
             settings: {
                 stream: false,
                 stagnationDetection: !['0', 'false', 'no', 'off'].includes(
-                    (process.env.KEPLER_STAGNATION_DETECTION ?? '0').toLowerCase(),
+                    (process.env.BAHULAM_STAGNATION_DETECTION ?? '0').toLowerCase(),
                 ),
                 stagnationThreshold: Number.parseInt(
-                    process.env.KEPLER_STAGNATION_THRESHOLD
+                    process.env.BAHULAM_STAGNATION_THRESHOLD
                     ?? '3',
                     10,
                 ),

package/src/tools/analyze-image.mjs

@@ -0,0 +1,158 @@
+/**
+ * analyze_image — ask a vision model about a local image file.
+ *
+ * The CLI owns local filesystem access, so this tool reads the image bytes and
+ * sends the same bounded attachment shape used by the preflight vision path to
+ * the authenticated backend `/api/vision/analyze` endpoint.
+ */
+import { BahulamAuth } from '../auth/bahulam-auth.mjs';
+import {
+  loadImageAttachment,
+  publicAttachmentMetadata,
+} from '../core/attachments.mjs';
+
+function visionFailureMessage(message, attachment) {
+  const base = String(message || 'Vision analysis failed').trim().replace(/[.。]+$/g, '');
+  const lower = base.toLowerCase();
+  const guidance = `File was loaded as ${attachment?.mime_type || 'an image'}; do not retry this image with read_attachment.`;
+  if (lower.includes('empty analysis') || lower.includes('no text answer') || lower.includes('no visible text answer') || lower.includes('finish_reason=length')) {
+    return `${base}. ${guidance} The provider call completed but did not return visible answer text; retry analyze_image with a more specific question or switch the configured vision model.`;
+  }
+  return `${base}. ${guidance}`;
+}
+
+export const AnalyzeImageTool = {
+  name: 'analyze_image',
+  description:
+    'Answer a specific question about a local image file. Pass path=<local image path> and question=<what to inspect>. Use for screenshots, diagrams, photos, and UI images.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      path: {
+        type: 'string',
+        description: 'Local image file path. JPEG, PNG, WebP, and GIF are supported.',
+      },
+      file_path: {
+        type: 'string',
+        description: 'Alias for path.',
+      },
+      upload_id: {
+        type: 'string',
+        description: 'Chat-only image upload id. Not supported in the CLI; use path instead.',
+      },
+      question: {
+        type: 'string',
+        description: 'Specific question to ask about the image. Example: "Describe the UI layout and visible errors."',
+      },
+    },
+    required: ['question'],
+  },
+
+  validateInput(input) {
+    const errors = [];
+    const pathValue = String(input?.path || input?.file_path || '').trim();
+    const uploadId = String(input?.upload_id || '').trim();
+    if (!pathValue && !uploadId) errors.push('path is required');
+    if (!String(input?.question || '').trim()) errors.push('question is required');
+    return errors;
+  },
+
+  async call(input) {
+    const uploadId = String(input?.upload_id || '').trim();
+    const rawPath = String(input?.path || input?.file_path || '').trim();
+    const question = String(input?.question || '').trim() || 'Describe this image in detail.';
+
+    if (uploadId && !rawPath) {
+      return {
+        success: false,
+        output: 'upload_id is a chat-only mode. In the CLI, pass path=<local image path>.',
+        _tool: 'analyze_image',
+      };
+    }
+    if (!rawPath) {
+      return {
+        success: false,
+        output: 'analyze_image requires path=<local image path>.',
+        _tool: 'analyze_image',
+      };
+    }
+
+    let attachment;
+    try {
+      attachment = loadImageAttachment(rawPath, { cwd: process.cwd() });
+    } catch (err) {
+      return {
+        success: false,
+        output: `Failed to load image: ${err.message || err}`,
+        _tool: 'analyze_image',
+      };
+    }
+
+    const creds = new BahulamAuth().loadCredentials();
+    if (!creds.backendUrl || !creds.token) {
+      return {
+        success: false,
+        output: 'analyze_image requires CLI auth. Run `bahulam-code login` or set B0_TOKEN/KEPLER_TOKEN.',
+        _tool: 'analyze_image',
+      };
+    }
+
+    let response;
+    try {
+      response = await fetch(`${creds.backendUrl}/api/vision/analyze`, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${creds.token}`,
+          'Content-Type': 'application/json',
+          'X-Product': process.env.BAHULAM_PRODUCT || 'bahulam',
+        },
+        body: JSON.stringify({
+          instruction: question,
+          attachments: [attachment],
+        }),
+      });
+    } catch (err) {
+      return {
+        success: false,
+        output: `Vision analysis unreachable: ${err.message || err}`,
+        _tool: 'analyze_image',
+      };
+    }
+
+    const text = await response.text().catch(() => '');
+    let payload = null;
+    try {
+      payload = text ? JSON.parse(text) : null;
+    } catch {
+      payload = { detail: text };
+    }
+
+    if (!response.ok) {
+      const detail = payload?.detail || payload || {};
+      const message = typeof detail === 'string'
+        ? detail
+        : detail.message || detail.error || `Vision analysis failed (${response.status})`;
+      return {
+        success: false,
+        output: visionFailureMessage(message, attachment),
+        status: response.status,
+        detail,
+        _tool: 'analyze_image',
+      };
+    }
+
+    const summary = String(payload?.summary || '').trim();
+    return {
+      success: true,
+      output: summary || '(no vision summary returned)',
+      summary,
+      model: payload?.model || '',
+      provider: payload?.provider || 'backend-vision',
+      attachments: Array.isArray(payload?.attachments)
+        ? payload.attachments
+        : [publicAttachmentMetadata(attachment)],
+      usage: payload?.usage || {},
+      _tool: 'analyze_image',
+    };
+  },
+};

package/src/tools/bash.mjs

@@ -18,6 +18,7 @@ function stripAnsi(str) {
 
 const MAX_OUTPUT_BYTES = 1024 * 1024; // 1MB
 const TIMEOUT_TAIL_BYTES = 64 * 1024;
+const TRUNCATION_MARKER = '\n[output truncated at 1MB]';
 
 export const BashTool = {
     name: 'shell',
@@ -55,6 +56,8 @@ export const BashTool = {
             let stderr = '';
             let stdoutTail = '';
             let stderrTail = '';
+            let stdoutTruncated = false;
+            let stderrTruncated = false;
             let killed = false;
             let cancelled = false;
             let exitCode = null;
@@ -98,13 +101,17 @@ export const BashTool = {
 
             proc.stdout.on('data', (chunk) => {
                 const text = chunk.toString();
-                stdout = appendHead(stdout, text, MAX_OUTPUT_BYTES);
+                const next = appendHead(stdout, text, MAX_OUTPUT_BYTES);
+                if (next.length < stdout.length + text.length) stdoutTruncated = true;
+                stdout = next;
                 stdoutTail = appendTail(stdoutTail, text, TIMEOUT_TAIL_BYTES);
             });
 
             proc.stderr.on('data', (chunk) => {
                 const text = chunk.toString();
-                stderr = appendHead(stderr, text, MAX_OUTPUT_BYTES);
+                const next = appendHead(stderr, text, MAX_OUTPUT_BYTES);
+                if (next.length < stderr.length + text.length) stderrTruncated = true;
+                stderr = next;
                 stderrTail = appendTail(stderrTail, text, TIMEOUT_TAIL_BYTES);
             });
 
@@ -116,13 +123,8 @@ export const BashTool = {
             proc.on('close', (code) => {
                 exitCode = code;
 
-                // Truncate if over limit
-                if (stdout.length > MAX_OUTPUT_BYTES) {
-                    stdout = stdout.slice(0, MAX_OUTPUT_BYTES) + '\n[output truncated at 1MB]';
-                }
-                if (stderr.length > MAX_OUTPUT_BYTES) {
-                    stderr = stderr.slice(0, MAX_OUTPUT_BYTES) + '\n[output truncated at 1MB]';
-                }
+                if (stdoutTruncated) stdout += TRUNCATION_MARKER;
+                if (stderrTruncated) stderr += TRUNCATION_MARKER;
 
                 // Strip ANSI by default
                 stdout = stripAnsi(stdout);