@bahulam/code 0.1.6 → 0.1.8

package/src/core/tool-executor.mjs

@@ -1,7 +1,7 @@
 /**
- * Tool Executor Bridge — maps Tarang backend tool names to OCC tool calls.
+ * Tool Executor Bridge — maps Bahulam backend tool names to OCC tool calls.
  *
- * The Tarang backend sends tool_request events with its own tool names and arg shapes.
+ * The Bahulam backend sends tool_request events with its own tool names and arg shapes.
  * This bridge translates those into OCC tool calls and wraps the results.
  *
  * Safety guardrails integrated — prevents destructive operations on source code.
@@ -18,21 +18,23 @@ import { SkillInstaller } from '../skills/installer.mjs';
 import { SkillsLoader } from '../skills/loader.mjs';
 import { createAgentFile, listLocalAgents, syncAgentsToBackend } from '../agents/scaffold.mjs';
 import { createWorkflowFile, listLocalWorkflows, WORKFLOW_SYNC_ENDPOINT, slugifyWorkflowName } from '../agents/workflow_scaffold.mjs';
-import { TarangAuth } from '../auth/tarang-auth.mjs';
+import { BahulamAuth } from '../auth/bahulam-auth.mjs';
+import { detectImageFile } from './attachments.mjs';
 import { streamResponse } from './streaming.mjs';
 import { sendApprovalDecision, sendCallback } from './callback-client.mjs';
 import { HookRunner } from '../config/hook-runner.mjs';
 import { buildFileDiff } from './file-diff.mjs';
 import { buildWorkScope } from './work-scope.mjs';
 import { loadDiskMemory, ensureBahulamDir, globalMemoryPath, projectMemoryPath } from './memory-disk.mjs';
+import { resolveLintCommand } from './lint-resolver.mjs';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import * as crypto from 'node:crypto';
-import { execSync } from 'node:child_process';
+import { exec, execSync } from 'node:child_process';
 
 /**
- * Create a tool executor that bridges Tarang tool names to OCC tools.
+ * Create a tool executor that bridges Bahulam tool names to OCC tools.
  * @param {Object} [options]
  * @param {ProjectRegistry} [options.projectRegistry] - session-owned project registry
  * @returns {{ execute(name, args): Promise<Object>, listTools(): string[] }}
@@ -470,7 +472,7 @@ export function createToolExecutor({
     }
 
     /**
-     * Wrap an OCC string result into Tarang's { success, output } format.
+     * Wrap an OCC string result into Bahulam's { success, output } format.
      */
     function wrapResult(result, toolName) {
         if (typeof result === 'object' && result !== null && 'success' in result) {
@@ -487,43 +489,39 @@ export function createToolExecutor({
 
     // ── Auto-lint after file writes ────────────────────────────
 
-    const LINT_COMMANDS = {
-        '.py':  (file) => `python3 -m py_compile "${file}" 2>&1`,
-        '.js':  (file) => `npx eslint --no-eslintrc --rule '{}' "${file}" 2>&1 || true`,
-        '.ts':  (file) => `npx tsc --noEmit --pretty "${file}" 2>&1 || true`,
-        '.tsx': (file) => `npx tsc --noEmit --pretty "${file}" 2>&1 || true`,
-        '.go':  (file) => `go vet "${file}" 2>&1`,
-        '.rs':  (file) => `rustfmt --check "${file}" 2>&1`,
-    };
-
     // tsc --pretty and eslint emit ANSI codes (including background-red
     // highlights) which bleed when our renderer slices the first 80 chars.
     // Strip color codes so the stored lint string is always plain text.
     const ANSI_RE = /\x1b\[[0-9;]*[a-zA-Z]/g;
     function stripAnsi(s) { return String(s || '').replace(ANSI_RE, ''); }
 
-    function autoLint(filePath) {
-        const ext = path.extname(filePath);
-        const cmdFn = LINT_COMMANDS[ext];
-        if (!cmdFn) return null;
-
-        try {
-            const output = execSync(cmdFn(filePath), {
+    function runAutoLintCommand(lint) {
+        return new Promise((resolve) => {
+            exec(lint.command, {
                 encoding: 'utf-8',
                 timeout: 15_000,
-                cwd: process.cwd(),
-                stdio: ['pipe', 'pipe', 'pipe'],
+                cwd: lint.cwd,
+                maxBuffer: 1_000_000,
                 env: { ...process.env, FORCE_COLOR: '0', NO_COLOR: '1', TERM: 'dumb' },
+            }, (err, stdout = '', stderr = '') => {
+                const output = err
+                    ? stripAnsi(stderr || stdout || '').trim()
+                    : stripAnsi(stdout || stderr || '').trim();
+                resolve(output || null);
             });
-            const trimmed = stripAnsi(output).trim();
-            if (!trimmed) return null;
-            return trimmed;
-        } catch (err) {
-            // Non-zero exit means lint errors found
-            const output = stripAnsi(err.stderr || err.stdout || '').trim();
-            if (!output) return null;
-            return output;
-        }
+        });
+    }
+
+    async function autoLint(filePath) {
+        const project = projectRegistry.projectForPath(filePath);
+        const lint = resolveLintCommand(filePath, {
+            projectRoot: project?.resource?.root || projectRootFor(filePath),
+            projectCommands: project?.resource?.commands || {},
+            allowProjectScript: false,
+        });
+        if (!lint?.command) return null;
+
+        return runAutoLintCommand(lint);
     }
 
     // ── Post-edit verification hint ──────────────────────────────
@@ -695,6 +693,52 @@ export function createToolExecutor({
             };
         },
 
+        analyze_image: async (args, options = {}) => {
+            throwIfAborted(options.signal);
+            const tool = occRegistry.get('analyze_image');
+            if (!tool) {
+                return { success: false, output: 'analyze_image tool is not registered in the CLI.', _tool: 'analyze_image' };
+            }
+            try {
+                const result = await tool.call(args || {});
+                throwIfAborted(options.signal);
+                if (typeof result === 'string') {
+                    return { success: !/^error\b/i.test(result), output: result, _tool: 'analyze_image' };
+                }
+                return {
+                    success: result?.success !== false,
+                    output: result?.output || result?.summary || JSON.stringify(result),
+                    ...result,
+                    _tool: 'analyze_image',
+                };
+            } catch (err) {
+                return { success: false, output: String(err?.message || err), _tool: 'analyze_image' };
+            }
+        },
+
+        generate_image: async (args, options = {}) => {
+            throwIfAborted(options.signal);
+            const tool = occRegistry.get('generate_image');
+            if (!tool) {
+                return { success: false, output: 'generate_image tool is not registered in the CLI.', _tool: 'generate_image' };
+            }
+            try {
+                const result = await tool.call(args || {});
+                throwIfAborted(options.signal);
+                if (typeof result === 'string') {
+                    return { success: !/^error\b/i.test(result), output: result, _tool: 'generate_image' };
+                }
+                return {
+                    success: result?.success !== false,
+                    output: result?.output || JSON.stringify(result),
+                    ...result,
+                    _tool: 'generate_image',
+                };
+            } catch (err) {
+                return { success: false, output: String(err?.message || err), _tool: 'generate_image' };
+            }
+        },
+
         // 0b. read_attachment → chunked text extraction from a local document.
         // Backend registers the schema; execution happens client-side because
         // only the CLI has the user's filesystem. Supports the `path` mode
@@ -734,6 +778,17 @@ export function createToolExecutor({
                 return { success: false, output: String(err?.message || err), _tool: 'read_attachment' };
             }
 
+            const imageInfo = detectImageFile(abs);
+            if (imageInfo) {
+                return {
+                    success: false,
+                    output: `This file is an image (${imageInfo.mime_type}). read_attachment only extracts text documents. Use analyze_image with a specific question. If analyze_image already failed, report that vision error directly instead of retrying this image with read_attachment.`,
+                    _tool: 'read_attachment',
+                    _path: abs,
+                    _mime: imageInfo.mime_type,
+                };
+            }
+
             const { extractFromPath } = await import('../context/prose-chunker.mjs');
             let mime, chunks;
             try {
@@ -747,7 +802,7 @@ export function createToolExecutor({
             if (!chunks.length) {
                 return {
                     success: false,
-                    output: `Unsupported or empty file (mime=${mime}). Supported: pdf, txt, md/mdx, csv, tsv, json, yaml, toml, html, log, rst. For CSV/Excel analysis use read_table; for images use analyze_image.`,
+                    output: `Unsupported or empty file (mime=${mime}). Supported text: pdf, txt, md/mdx, ipynb, csv, tsv, json, yaml, toml, xml, html, log, rst, sql, sh, .env, .ini, Dockerfile, .gitignore — plus any file whose first 8KB is valid UTF-8 (auto-sniffed). For CSV/Excel analysis use read_table; for images use analyze_image. If analyze_image already failed for this file, report that vision error directly instead of retrying with read_attachment.`,
                     _tool: 'read_attachment',
                 };
             }
@@ -966,10 +1021,12 @@ export function createToolExecutor({
                     filteredLines: rawOutput.split('\n').length,
                 }
                 : filterOutput(rawOutput, args.command, success);
+            const agentOutput = observationTimeout && timedOut ? filtered.output : rawOutput;
 
             return {
                 success,
-                output: filtered.output,
+                output: agentOutput,
+                output_preview: filtered.output,
                 exit_code: exitCode,
                 _tool: 'shell',
                 _classification: args._classification,
@@ -1087,7 +1144,7 @@ export function createToolExecutor({
             updateProjectIndex(filePath);
 
             // Auto-lint the written file
-            const lintOutput = autoLint(filePath);
+            const lintOutput = await autoLint(filePath);
             if (lintOutput) {
                 wrapped.output += `\n\n--- Lint ---\n${lintOutput}`;
                 wrapped.lint = lintOutput;
@@ -1180,9 +1237,21 @@ export function createToolExecutor({
         // 4. edit_file → Edit + auto-lint + auto-fallback to sed
         edit_file: async (args) => {
             const rawPath = args.file_path || args.path;
+            const searchText = args.search ?? args.old_string ?? args.oldString;
+            const replaceText = args.replace ?? args.new_string ?? args.newString;
+            const replaceAll = args.replace_all === true || args.replaceAll === true;
+            if (!rawPath || rawPath === 'file' || rawPath.length < 3) {
+                return { success: false, output: `Error: Invalid file path "${rawPath || ''}". Register the project, then use an absolute path.`, _tool: 'edit_file' };
+            }
+            if (typeof searchText !== 'string' || searchText.length === 0) {
+                return { success: false, output: 'Error: edit_file requires a non-empty search string.', _tool: 'edit_file' };
+            }
+            if (typeof replaceText !== 'string') {
+                return { success: false, output: 'Error: edit_file requires a replacement string.', _tool: 'edit_file' };
+            }
             const filePath = await resolvePath(rawPath, args);
             const before = readTextIfExists(filePath);
-            const writeCheck = validateWrite(filePath, args.replace, projectRootFor(filePath));
+            const writeCheck = validateWrite(filePath, replaceText, projectRootFor(filePath));
             if (!writeCheck.safe) {
                 return { success: false, output: `BLOCKED: ${writeCheck.reason}`, _tool: 'edit_file', _blocked: true };
             }
@@ -1200,46 +1269,51 @@ export function createToolExecutor({
             try {
                 result = await occRegistry.call('edit_file', {
                     file_path: filePath,
-                    search: args.search,
-                    replace: args.replace,
-                    replace_all: args.replace_all || false,
+                    search: searchText,
+                    replace: replaceText,
+                    replace_all: replaceAll,
                 });
             } catch (editErr) {
-                // OCC Edit failed (string not found) — fallback to Python replacement
+                // OCC Edit failed (string not found) — fallback to direct text replacement.
                 try {
-                    const search = args.search.replace(/'/g, "\\'").replace(/\n/g, "\\n");
-                    const replace = args.replace.replace(/'/g, "\\'").replace(/\n/g, "\\n");
-                    const pyCmd = `python3 -c "
-import sys
-with open('${filePath}', 'r') as f: content = f.read()
-old = '''${args.search}'''
-new = '''${args.replace}'''
-if old not in content:
-    print('ERROR: search string not found in file', file=sys.stderr)
-    sys.exit(1)
-content = content.replace(old, new, 1)
-with open('${filePath}', 'w') as f: f.write(content)
-print('OK: replaced')
-"`;
-                    const fallbackResult = execSync(pyCmd, {
-                        encoding: 'utf-8',
-                        timeout: 5000,
-                        cwd: projectRootFor(filePath),
-                    });
-                    result = `Edited ${filePath} (via fallback): ${fallbackResult.trim()}`;
-                } catch (sedErr) {
-                    return { success: false, output: `edit_file failed: ${editErr?.message || 'unknown'}. Fallback also failed: ${sedErr?.message || 'unknown'}. Try shell(sed) manually.`, _tool: 'edit_file' };
+                    const content = fs.readFileSync(filePath, 'utf-8');
+                    if (!content.includes(searchText)) {
+                        throw new Error('search string not found in file');
+                    }
+                    const nextContent = replaceAll
+                        ? content.split(searchText).join(replaceText)
+                        : content.replace(searchText, replaceText);
+                    if (nextContent !== content) {
+                        fs.writeFileSync(filePath, nextContent, 'utf-8');
+                    }
+                    result = `Edited ${filePath} (via fallback): OK: replaced`;
+                } catch (fallbackErr) {
+                    return { success: false, output: `edit_file failed: ${editErr?.message || 'unknown'}. Fallback also failed: ${fallbackErr?.message || 'unknown'}. Re-read the target range and provide an exact search string.`, _tool: 'edit_file' };
                 }
             }
 
             const wrapped = wrapResult(result, 'edit_file');
             const after = readTextIfExists(filePath);
+            if (wrapped.success !== false && before === after) {
+                const relativePath = path.relative(projectRootFor(filePath), filePath) || path.basename(filePath);
+                return {
+                    success: false,
+                    output: `edit_file made no changes to ${relativePath}. The search string may already be replaced, the replacement may be identical, or the target content may have drifted. Re-read the target range before trying a different edit.`,
+                    _tool: 'edit_file',
+                    _no_change: true,
+                    no_change: true,
+                    file_path: filePath,
+                    relative_path: relativePath,
+                    lines_added: 0,
+                    lines_removed: 0,
+                };
+            }
             attachFileDiff(wrapped, filePath, before, after);
             updateProjectIndex(filePath);
             _hasEdited = true;
 
             // Auto-lint the edited file
-            const lintOutput = autoLint(filePath);
+            const lintOutput = await autoLint(filePath);
             if (lintOutput) {
                 wrapped.output += `\n\n--- Lint ---\n${lintOutput}`;
                 wrapped.lint = lintOutput;
@@ -1449,7 +1523,7 @@ print('OK: replaced')
             };
         },
 
-        // ── Tarang-specific tools (no OCC bridge) ──────────────
+        // ── Bahulam-specific tools (no OCC bridge) ──────────────
 
         // 8. read_files → batch Read (with AST truncation for large files)
         read_files: async (args) => {
@@ -1608,24 +1682,44 @@ print('OK: replaced')
             try {
                 throwIfAborted(options.signal);
                 const filePath = await resolvePath(args.file_path || args.path, args);
-                const ext = path.extname(filePath);
-                let cmd;
-                if (ext === '.py') cmd = `python3 -m ruff check "${filePath}" 2>&1 || true`;
-                else if (['.js', '.mjs', '.ts', '.tsx'].includes(ext)) cmd = `npx eslint "${filePath}" 2>&1 || true`;
-                else return { success: true, issues: [], message: 'No linter for this file type', _tool: 'lint_check' };
+                const project = projectRegistry.projectForPath(filePath);
+                const lint = resolveLintCommand(filePath, {
+                    projectRoot: project?.resource?.root || projectRootFor(filePath),
+                    projectCommands: project?.resource?.commands || {},
+                    allowProjectScript: true,
+                });
+                if (!lint?.command) {
+                    return {
+                        success: true,
+                        issues: [],
+                        message: 'No project-aware linter for this path or file type',
+                        _tool: 'lint_check',
+                    };
+                }
 
-                const output = await occRegistry.call('shell', {
-                    command: cmd,
+                const shellResult = await executeToolWithHooks('shell', {
+                    command: lint.command,
                     timeout: 30_000,
-                    description: `Lint: ${path.basename(filePath)}`,
-                    cwd: projectRootFor(filePath),
-                    signal: options.signal,
-                });
-                const rawOutput = typeof output === 'string' ? output : String(output);
+                    description: `Lint: ${path.basename(filePath)} (${lint.source})`,
+                    cwd: lint.cwd,
+                }, options);
+                const rawOutput = typeof shellResult?.output === 'string'
+                    ? shellResult.output
+                    : (typeof shellResult === 'string' ? shellResult : String(shellResult));
                 if (/^Error:\s*Command cancelled by user/i.test(rawOutput)) {
                     return { success: false, output: 'Cancelled by user', _cancelled: true, _tool: 'lint_check' };
                 }
-                return { success: true, output: rawOutput, issues: rawOutput.split('\n').filter(Boolean), _tool: 'lint_check' };
+                const normalizedOutput = rawOutput === '(no output)' ? '' : rawOutput;
+                return {
+                    success: true,
+                    output: normalizedOutput || 'No lint issues found.',
+                    command: lint.command,
+                    cwd: lint.cwd,
+                    language: lint.language,
+                    lint_source: lint.source,
+                    issues: normalizedOutput.split('\n').filter(Boolean),
+                    _tool: 'lint_check',
+                };
             } catch (err) {
                 if (isAbortError(err) || options.signal?.aborted) return cancelledToolResult('lint_check');
                 return { success: false, output: err.message, _tool: 'lint_check' };
@@ -1858,7 +1952,7 @@ print('OK: replaced')
                 const target = args.name || args.slug || '';
                 throw new Error(target ? `No local agent found: ${target}` : 'No local agents found in .bahulam/agents');
             }
-            const creds = new TarangAuth().loadCredentials();
+            const creds = new BahulamAuth().loadCredentials();
             const result = await syncAgentsToBackend({
                 backendUrl: creds.backendUrl,
                 token: creds.token,
@@ -1880,7 +1974,7 @@ print('OK: replaced')
             const local = filterLocalWorkflows(args).map(compactWorkflowMetadata);
             let backend = [];
             try {
-                const creds = new TarangAuth().loadCredentials();
+                const creds = new BahulamAuth().loadCredentials();
                 if (creds.backendUrl && creds.token) {
                     const resp = await fetch(`${creds.backendUrl}${WORKFLOW_SYNC_ENDPOINT}`, {
                         headers: {
@@ -1946,7 +2040,7 @@ print('OK: replaced')
                 const target = args.name || args.slug || '';
                 throw new Error(target ? `No local workflow found: ${target}` : 'No local workflows found in .bahulam/workflows');
             }
-            const creds = new TarangAuth().loadCredentials();
+            const creds = new BahulamAuth().loadCredentials();
             if (!creds.backendUrl || !creds.token) {
                 throw new Error('Not logged in. Run bahulam login first.');
             }
@@ -2018,7 +2112,7 @@ print('OK: replaced')
             if (!target) {
                 throw new Error('workflow_id is required');
             }
-            const creds = new TarangAuth().loadCredentials();
+            const creds = new BahulamAuth().loadCredentials();
             if (!creds.backendUrl || !creds.token) {
                 throw new Error('Not logged in. Run bahulam login first.');
             }
@@ -2197,8 +2291,8 @@ print('OK: replaced')
 
     return {
         /**
-         * Execute a Tarang tool by name.
-         * @param {string} name - Tarang tool name
+         * Execute a Bahulam tool by name.
+         * @param {string} name - Bahulam tool name
          * @param {Object} args - Tool arguments
          * @returns {Promise<Object>} - { success, output, ... }
          */