@bahulam/code 0.1.6 → 0.1.7

package/src/tools/generate-image.mjs

@@ -0,0 +1,411 @@
+/**
+ * generate_image — text-to-image generation for Kepler Code.
+ *
+ * Uses the OpenRouter-compatible image API shape (`POST /v1/images`) and saves
+ * generated bytes to local files so the agent can use the assets in code.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { TarangAuth } from '../auth/tarang-auth.mjs';
+
+const DEFAULT_IMAGE_GENERATION_MODEL = 'google/gemini-3-pro-image';
+const MAX_GENERATED_IMAGE_BYTES = 10 * 1024 * 1024;
+
+export const GenerateImageTool = {
+    name: 'generate_image',
+    description:
+        'Generate new image files from a text prompt. Use for requested visual assets, hero images, icons, textures, mockups, and illustrations. Do not use to inspect uploaded images; use analyze_image for that.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            prompt: {
+                type: 'string',
+                description: 'Detailed image prompt: subject, composition, lighting, style, colors, background, and constraints.',
+            },
+            aspect_ratio: {
+                type: 'string',
+                enum: ['1:1', '4:3', '3:4', '16:9', '9:16', '21:9'],
+                description: 'Optional aspect ratio.',
+            },
+            resolution: {
+                type: 'string',
+                enum: ['512', '1K', '2K', '4K'],
+                description: 'Optional normalized resolution tier.',
+            },
+            quality: {
+                type: 'string',
+                enum: ['auto', 'low', 'medium', 'high'],
+                description: 'Optional quality hint.',
+            },
+            output_format: {
+                type: 'string',
+                enum: ['png', 'jpeg', 'webp', 'svg'],
+                description: 'Optional output format.',
+            },
+            n: {
+                type: 'integer',
+                minimum: 1,
+                maximum: 4,
+                description: 'Number of images to generate. Default 1.',
+            },
+            output_path: {
+                type: 'string',
+                description: 'Optional path under the current project. Defaults to generated-images/<prompt-slug>.<ext>.',
+            },
+            filename: {
+                type: 'string',
+                description: 'Optional filename alias. output_path takes precedence when both are provided.',
+            },
+            include_data_url: {
+                type: 'boolean',
+                description: 'Also return data:image/... URLs. Use sparingly; this can be large.',
+            },
+            overwrite: {
+                type: 'boolean',
+                description: 'Overwrite output_path if it already exists. Default false.',
+            },
+        },
+        required: ['prompt'],
+    },
+
+    validateInput(input) {
+        const errors = [];
+        if (!String(input?.prompt || '').trim()) errors.push('prompt is required');
+        return errors;
+    },
+
+    async call(input) {
+        const prompt = String(input.prompt || '').trim();
+        const n = boundedInt(input.n, 1, 1, 4);
+        const model = resolveImageModel();
+        let basePath;
+        try {
+            basePath = safeOutputBase(input.output_path || input.filename, prompt);
+        } catch (err) {
+            return { success: false, output: String(err?.message || err), _tool: 'generate_image' };
+        }
+
+        const request = {
+            model,
+            prompt,
+            n,
+            aspect_ratio: optionalString(input.aspect_ratio),
+            resolution: optionalString(input.resolution),
+            quality: optionalString(input.quality),
+            output_format: optionalString(input.output_format),
+            output_path: optionalString(input.output_path),
+            filename: optionalString(input.filename),
+        };
+        const creds = new TarangAuth().loadCredentials();
+        const apiKey = gatewayApiKey(creds);
+        let result;
+        if (creds.backendUrl && creds.token) {
+            result = await callBackendImageApi({
+                backendUrl: creds.backendUrl,
+                token: creds.token,
+                product: process.env.BAHULAM_PRODUCT || 'bahulam',
+                ...request,
+            });
+        } else if (apiKey) {
+            result = await callImageApi({ apiKey, ...request });
+        } else {
+            return {
+                success: false,
+                output: 'Image generation unavailable: sign in with `bahulam-code login` or configure OPENROUTER_API_KEY / BAHULAM_GATEWAY_API_KEY for direct local generation.',
+                _tool: 'generate_image',
+            };
+        }
+        if (result.error) {
+            return { success: false, output: result.error, _tool: 'generate_image' };
+        }
+
+        const resultModel = result.model || model;
+        const images = [];
+        for (let i = 0; i < result.images.length; i += 1) {
+            const item = result.images[i];
+            const mediaType = mediaTypeFor(item.media_type, input.output_format);
+            const buffer = Buffer.from(item.b64_json, 'base64');
+            if (buffer.length > maxGeneratedImageBytes()) {
+                return {
+                    success: false,
+                    output: `Generated image is ${buffer.length} bytes; cap is ${maxGeneratedImageBytes()} bytes.`,
+                    _tool: 'generate_image',
+                };
+            }
+
+            const filePath = await outputPathFor(basePath, i + 1, result.images.length, mediaType, Boolean(input.overwrite));
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            await fs.writeFile(filePath, buffer);
+
+            const image = {
+                path: filePath,
+                mime: mediaType,
+                size_bytes: buffer.length,
+            };
+            if (input.include_data_url) {
+                image.data_url = `data:${mediaType};base64,${item.b64_json}`;
+            }
+            images.push(image);
+        }
+
+        const usage = result.usage || {};
+        const cost = usage.cost != null ? `, cost=${usage.cost}` : '';
+        return {
+            success: true,
+            output: [
+                `Generated ${images.length} image${images.length === 1 ? '' : 's'} with ${resultModel}${cost}:`,
+                ...images.map((image) => `- ${image.path} (${image.mime}, ${image.size_bytes} bytes)`),
+            ].join('\n'),
+            images,
+            model: resultModel,
+            provider: result.provider || 'openrouter-compatible',
+            usage,
+            _tool: 'generate_image',
+        };
+    },
+};
+
+async function callBackendImageApi({
+    backendUrl,
+    token,
+    product,
+    prompt,
+    n,
+    aspect_ratio,
+    resolution,
+    quality,
+    output_format,
+    output_path,
+    filename,
+}) {
+    const body = { prompt, include_data_url: true };
+    if (n > 1) body.n = n;
+    if (aspect_ratio) body.aspect_ratio = aspect_ratio;
+    if (resolution) body.resolution = resolution;
+    if (quality) body.quality = quality;
+    if (output_format) body.output_format = output_format;
+    if (output_path) body.output_path = output_path;
+    if (filename) body.filename = filename;
+
+    let response;
+    try {
+        response = await fetch(`${backendUrl}/api/images/generate`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json',
+                'X-Product': product || 'bahulam',
+            },
+            body: JSON.stringify(body),
+        });
+    } catch (err) {
+        return { error: `Image generation backend unreachable: ${err.message || err}` };
+    }
+
+    const payload = await readJsonResponse(response);
+    if (!response.ok) {
+        return { error: `Image generation backend error (${response.status}): ${errorMessage(payload, response.status)}` };
+    }
+
+    const data = Array.isArray(payload?.images) ? payload.images : [];
+    if (!data.length) return { error: 'Image generation backend returned no image data.' };
+    const images = [];
+    for (const item of data) {
+        const parsed = normalizeImageData(item, output_format);
+        if (parsed.error) return parsed;
+        images.push(parsed);
+    }
+    return {
+        images,
+        model: payload?.model || '',
+        provider: payload?.provider || 'bahulam',
+        usage: payload?.usage || {},
+    };
+}
+
+async function callImageApi({ apiKey, model, prompt, n, aspect_ratio, resolution, quality, output_format }) {
+    const body = { model, prompt };
+    if (n > 1) body.n = n;
+    if (aspect_ratio) body.aspect_ratio = aspect_ratio;
+    if (resolution) body.resolution = resolution;
+    if (quality) body.quality = quality;
+    if (output_format) body.output_format = output_format;
+
+    const baseUrl = imageApiBaseUrl();
+    let response;
+    try {
+        response = await fetch(`${baseUrl}/images`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+                'X-Product': process.env.BAHULAM_PRODUCT || 'kepler',
+                'X-Bahulam-Client': 'kepler-code-image-generation',
+            },
+            body: JSON.stringify(body),
+        });
+    } catch (err) {
+        return { error: `Image generation model unreachable: ${err.message || err}` };
+    }
+
+    const payload = await readJsonResponse(response);
+    if (!response.ok) {
+        return { error: `Image generation model error (${response.status}): ${errorMessage(payload, response.status)}` };
+    }
+
+    const data = Array.isArray(payload.data) ? payload.data : [];
+    if (!data.length) return { error: 'Image generation model returned no image data.' };
+    const images = [];
+    for (const item of data) {
+        const parsed = normalizeImageData(item, output_format);
+        if (parsed.error) return parsed;
+        images.push(parsed);
+    }
+    return { images, model, provider: 'openrouter-compatible', usage: payload.usage || {} };
+}
+
+function imageApiBaseUrl() {
+    return String(
+        process.env.BAHULAM_IMAGE_GENERATION_BASE_URL ||
+        process.env.BAHULAM_GATEWAY_URL ||
+        process.env.OPENROUTER_BASE_URL ||
+        'https://openrouter.ai/api/v1'
+    ).replace(/\/+$/, '');
+}
+
+function gatewayApiKey(creds = {}) {
+    return String(
+        process.env.BAHULAM_GATEWAY_SERVICE_TOKEN ||
+        process.env.BAHULAM_API_KEY ||
+        process.env.BAHULAM_CLI_TOKEN ||
+        process.env.BAHULAM_GATEWAY_API_KEY ||
+        process.env.OPENROUTER_API_KEY ||
+        creds.openRouterKey ||
+        ''
+    ).trim();
+}
+
+async function readJsonResponse(response) {
+    const text = await response.text().catch(() => '');
+    try {
+        return text ? JSON.parse(text) : {};
+    } catch {
+        return { error: text };
+    }
+}
+
+function errorMessage(payload, status) {
+    const detail = payload?.detail || payload?.error || payload?.message || `HTTP ${status}`;
+    if (typeof detail === 'string') return detail.slice(0, 500);
+    return String(detail.message || detail.error || JSON.stringify(detail)).slice(0, 500);
+}
+
+function normalizeImageData(item, requestedFormat) {
+    if (item?.b64_json) {
+        return {
+            b64_json: String(item.b64_json),
+            media_type: mediaTypeFor(item.media_type || item.mime, requestedFormat),
+        };
+    }
+    const dataUrl = String(item?.data_url || '').trim();
+    const parsed = parseDataUrl(dataUrl);
+    if (parsed) return parsed;
+    return { error: 'Image generation returned an image without base64 data.' };
+}
+
+function parseDataUrl(dataUrl) {
+    const match = dataUrl.match(/^data:([^;,]+);base64,([\s\S]+)$/);
+    if (!match) return null;
+    return { media_type: match[1].toLowerCase(), b64_json: match[2] };
+}
+
+function resolveImageModel() {
+    return String(
+        process.env.BAHULAM_IMAGE_GENERATION_MODEL ||
+        process.env.BAHULAM_CHAT_IMAGE_GENERATION_MODEL ||
+        process.env.BAHULAM_IMAGE_GENERATION_MODEL_PAID ||
+        process.env.BAHULAM_IMAGE_GENERATION_MODEL_FREE ||
+        DEFAULT_IMAGE_GENERATION_MODEL
+    ).trim();
+}
+
+function boundedInt(value, defaultValue, min, max) {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed)) return defaultValue;
+    return Math.max(min, Math.min(max, parsed));
+}
+
+function optionalString(value) {
+    const text = String(value || '').trim();
+    return text || null;
+}
+
+function maxGeneratedImageBytes() {
+    const value = Number.parseInt(process.env.BAHULAM_IMAGE_GENERATION_MAX_BYTES || '', 10);
+    return Number.isFinite(value) && value > 0 ? value : MAX_GENERATED_IMAGE_BYTES;
+}
+
+function safeOutputBase(outputPath, prompt) {
+    const raw = String(outputPath || '').trim();
+    const fallback = path.join('generated-images', `${slugify(prompt)}.png`);
+    const target = raw || fallback;
+    const resolved = path.resolve(process.cwd(), target);
+    const root = `${path.resolve(process.cwd())}${path.sep}`;
+    if (resolved !== path.resolve(process.cwd()) && !resolved.startsWith(root)) {
+        throw new Error('output_path must stay inside the current project directory');
+    }
+    return resolved;
+}
+
+async function outputPathFor(basePath, index, total, mediaType, overwrite) {
+    const ext = extensionFor(mediaType);
+    const parsed = path.parse(basePath);
+    const stem = parsed.ext ? path.join(parsed.dir, parsed.name) : basePath;
+    const base = `${stem}${total > 1 ? `-${index}` : ''}.${ext}`;
+    if (overwrite) return base;
+    return uniquePath(base);
+}
+
+async function uniquePath(filePath) {
+    if (!(await exists(filePath))) return filePath;
+    const parsed = path.parse(filePath);
+    for (let i = 2; i < 1000; i += 1) {
+        const candidate = path.join(parsed.dir, `${parsed.name}-${i}${parsed.ext}`);
+        if (!(await exists(candidate))) return candidate;
+    }
+    throw new Error(`Could not choose a unique output path for ${filePath}`);
+}
+
+async function exists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+function mediaTypeFor(raw, requestedFormat) {
+    const media = String(raw || '').trim().toLowerCase();
+    if (media.startsWith('image/')) return media;
+    const requested = String(requestedFormat || '').trim().toLowerCase();
+    if (requested === 'jpeg' || requested === 'jpg') return 'image/jpeg';
+    if (requested === 'webp') return 'image/webp';
+    if (requested === 'svg') return 'image/svg+xml';
+    return 'image/png';
+}
+
+function extensionFor(mediaType) {
+    if (mediaType === 'image/jpeg') return 'jpg';
+    if (mediaType === 'image/webp') return 'webp';
+    if (mediaType === 'image/svg+xml') return 'svg';
+    return 'png';
+}
+
+function slugify(prompt) {
+    const words = String(prompt || '')
+        .toLowerCase()
+        .match(/[a-z0-9]+/g);
+    return (words || ['generated', 'image']).slice(0, 6).join('-') || 'generated-image';
+}

package/src/tools/lint.mjs

@@ -1,37 +1,20 @@
 /**
- * Lint Tool — run linters and type checkers.
+ * Legacy lint tool wrapper.
  *
- * Always safe: read-only, no side effects (unless --fix).
- * Agent should use this instead of shell("ruff check .").
- *
- * Execution: direct on host (no sandbox needed for read-only).
- * With --fix: routes through sandbox if available.
+ * The active model-facing tool is `lint_check` in core/tool-executor.mjs.
+ * Keep this wrapper resolver-backed so older imports cannot drift back to a
+ * separate linter command table.
  */
 
 import { BashTool } from './bash.mjs';
-
-const LINTERS = {
-    ruff:    { cmd: (p, fix) => `ruff check ${fix ? '--fix ' : ''}${p}`, lang: 'python' },
-    mypy:    { cmd: (p) => `mypy ${p} --no-error-summary`, lang: 'python' },
-    pyright: { cmd: (p) => `pyright ${p}`, lang: 'python' },
-    pylint:  { cmd: (p) => `pylint ${p} --output-format=text`, lang: 'python' },
-    eslint:  { cmd: (p, fix) => `eslint ${fix ? '--fix ' : ''}${p}`, lang: 'javascript' },
-    tsc:     { cmd: () => 'tsc --noEmit', lang: 'typescript' },
-    flake8:  { cmd: (p) => `flake8 ${p}`, lang: 'python' },
-    biome:   { cmd: (p, fix) => `biome check ${fix ? '--fix ' : ''}${p}`, lang: 'javascript' },
-};
+import { resolveLintCommand } from '../core/lint-resolver.mjs';
 
 export const LintTool = {
     name: 'Lint',
-    description: 'Run a linter or type checker. Fast, read-only (unless --fix). Use this instead of Bash for code checking.',
+    description: 'Run the project-aware linter or syntax checker for a file or directory.',
     inputSchema: {
         type: 'object',
         properties: {
-            tool: {
-                type: 'string',
-                enum: Object.keys(LINTERS),
-                description: 'Which linter to run',
-            },
             path: {
                 type: 'string',
                 description: 'File or directory to lint (default: ".")',
@@ -39,33 +22,31 @@ export const LintTool = {
             },
             fix: {
                 type: 'boolean',
-                description: 'Apply auto-fixes (default: false)',
+                description: 'Auto-fix is not supported by the resolver-backed lint wrapper.',
                 default: false,
             },
         },
-        required: ['tool'],
     },
-    validateInput(input) {
-        const errors = [];
-        if (!input.tool) errors.push('tool is required');
-        if (input.tool && !LINTERS[input.tool]) errors.push(`Unknown linter: ${input.tool}. Supported: ${Object.keys(LINTERS).join(', ')}`);
-        return errors;
+    validateInput(input = {}) {
+        if (input.fix) return ['fix=true is not supported here; run an explicit shell command for fixes'];
+        return [];
     },
-    async call(input) {
-        const linter = LINTERS[input.tool];
-        if (!linter) return `Unknown linter: ${input.tool}`;
-
+    async call(input = {}) {
         const targetPath = input.path || '.';
-        const command = linter.cmd(targetPath, input.fix);
-
-        const result = await BashTool.call({
-            command,
-            timeout: 30000, // linters should be fast
-            description: `Lint: ${input.tool} ${targetPath}`,
+        const lint = resolveLintCommand(targetPath, {
+            projectRoot: process.cwd(),
+            allowProjectScript: true,
         });
+        if (!lint?.command) {
+            return `No project-aware linter for path or file type: ${targetPath}`;
+        }
 
-        return result;
+        return await BashTool.call({
+            command: lint.command,
+            timeout: 30000,
+            cwd: lint.cwd,
+            description: `Lint: ${targetPath} (${lint.source})`,
+        });
     },
-    // Metadata for execution policy
-    _executionPolicy: 'direct', // no sandbox for read-only; 'contained' if fix=true
+    _executionPolicy: 'direct',
 };

package/src/tools/registry.mjs

@@ -37,6 +37,8 @@ import { SearchFilesTool } from './search-files.mjs';
 import { AnalyzeCodeTool } from './analyze-code.mjs';
 import { ExploreTool, PlanTool, VerifyTool, DebugTool, RefactorTool } from './meta-tools.mjs';
 import { RememberTool } from './remember.mjs';
+import { GenerateImageTool } from './generate-image.mjs';
+import { AnalyzeImageTool } from './analyze-image.mjs';
 
 const BUILTIN_TOOLS = [
     BashTool,
@@ -71,6 +73,8 @@ const BUILTIN_TOOLS = [
     ReadFilesTool,
     SearchFilesTool,
     AnalyzeCodeTool,
+    AnalyzeImageTool,
+    GenerateImageTool,
     ExploreTool,
     PlanTool,
     VerifyTool,

package/src/ui/icons.mjs

@@ -74,6 +74,7 @@ const TOOL_ICON = Object.freeze({
   grep:              'search',
   list_files:        'search',
   analyze_code:      'search',
+  analyze_image:     'search',
   get_file_info:     'search',
   git_diff:          'search',
   git_status:        'search',
@@ -84,6 +85,7 @@ const TOOL_ICON = Object.freeze({
   write_project:     'write',
   edit_file:         'write',
   delete_file:       'write',
+  generate_image:    'write',
 
   // Shell / validate
   shell:             'shell',

package/src/ui/palette.mjs

@@ -1,5 +1,5 @@
 /**
- * Kepler palette — semantic color tokens for the CLI.
+ * Bahulam palette — semantic color tokens for the CLI.
  *
  * Every feature module imports from here, never from raw ANSI. Tokens resolve
  * at call time so changing terminal capabilities (resize, `refresh()`) is

package/src/ui/slash-commands.mjs

@@ -52,12 +52,12 @@ export const COMMANDS = {
   '/review':      'Code review agent',
   '/architect':   'Feature architect agent',
   '/safety':      'Show safety guardrail status',
-  '/auto':        'Session autopilot: auto-approve routine tools (dangerous still prompts)',
-  '/approvals':   'List or edit session approval grants',
-  '/revoke':      'Revoke auto-approvals',
+  '/auto':        'Session autopilot: `/auto` routine-only · `/auto full` everything · `/auto off`',
+  '/approvals':   'List or edit session approval grants (`/approvals clear` revokes all)',
   '/resume':      'Resume a previous session',
   '/sessions':    'List resumable sessions',
   '/logout':      'Sign out and clear credentials',
+  '/watch':       'Toggle live agent activity tracking panel',
   '/exit':        'Exit CLI',
 };
 
@@ -118,7 +118,6 @@ export const HELP_GROUPS = [
       ['/settings logout', 'Sign out'],
       ['/settings whoami', 'Current user'],
       ['/settings quiet|verbose|surgical', 'Verbosity'],
-      ['/settings revoke', 'Revoke auto-approvals'],
     ],
   },
   {
@@ -138,6 +137,7 @@ export const HELP_GROUPS = [
     title: 'Agents',
     summary: 'specialist modes',
     commands: [
+      ['/watch', 'Toggle live agent tracking panel'],
       ['/agents', 'List built-in and local agents'],
       ['/agents create <name>', 'Create .bahulam/agents/<name>.yaml'],
       ['/agents edit <name>', 'Open local agent YAML'],
@@ -207,7 +207,6 @@ export const LEGACY_COMMAND_HINTS = {
   '/quiet':      '/settings quiet',
   '/verbose':    '/settings verbose',
   '/surgical':   '/settings surgical',
-  '/revoke':     '/settings revoke',
 };
 
 // Namespaced subcommands. `/status metrics` -> `/stats`, etc.
@@ -235,7 +234,6 @@ export const NAMESPACED_COMMANDS = {
     quiet:    '/quiet',
     verbose:  '/verbose',
     surgical: '/surgical',
-    revoke:   '/revoke',
   },
 };
 

package/src/ui/tool-card.mjs

@@ -159,7 +159,7 @@ export function summarizeResult(tool, data) {
         // Multi-row preview: first N rows + a "+ M more" tail so long
         // outputs (e.g. `ls`) surface their scale instead of collapsing
         // to a single first line with no hint that more exists.
-        const { preview, remaining } = outputPreviewRows(data, shellPreviewRows());
+        const { preview, remaining } = outputPreviewRows(data, shellPreviewRows(data));
         if (!preview) return { text: 'ok', tone: 'success' };
         if (remaining === 0) return { text: preview, tone: 'success' };
         const tail = paint.text.dim(`+ ${remaining} more row${remaining === 1 ? '' : 's'}`);
@@ -434,9 +434,13 @@ function outputPreviewRows(data, n, perRow = 200) {
 // Default rows shown in the shell result preview. Overridable via env for
 // power users; keep it small — the result line rides above every command
 // and eats vertical space in a long session.
-function shellPreviewRows() {
+function shellPreviewRows(data = {}) {
   const raw = parseInt(process.env.BAHULAM_SHELL_PREVIEW_ROWS ?? '', 10);
-  return Number.isFinite(raw) && raw >= 1 ? raw : 2;
+  if (Number.isFinite(raw) && raw >= 1) return raw;
+  const command = String(data?.args?.command || data?.command || '');
+  if (/^\s*git\s+(diff|show)\b/i.test(command)) return 8;
+  if (/^\s*git\s+status\b/i.test(command)) return 8;
+  return 2;
 }
 
 function lineCount(s) {