@bahulam/code 0.1.6 → 0.1.8

package/src/tools/generate-image.mjs

@@ -0,0 +1,411 @@
+/**
+ * generate_image — text-to-image generation for Bahulam 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 { BahulamAuth } from '../auth/bahulam-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 BahulamAuth().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': 'bahulam-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/project-overview.mjs

@@ -322,8 +322,8 @@ function _readIfExists(dir, filename, maxChars = 8000) {
     } catch { return ''; }
 }
 
-function _scanSkills(keplerDir) {
-    const skillsDir = path.join(keplerDir, 'skills');
+function _scanSkills(bahulamDir) {
+    const skillsDir = path.join(bahulamDir, 'skills');
     if (!fs.existsSync(skillsDir)) return [];
     try {
         return fs.readdirSync(skillsDir, { withFileTypes: true })
@@ -402,15 +402,15 @@ export class ProjectRegistry {
     // .bahulam/KEPLER.md, goal/plan/style, skills, AGENTS.md, etc. changes.
     _attachLiveContext(resource, root) {
         // Resolver — prefers .bahulam/, falls back to .kepler/ for legacy projects.
-        const keplerDir = projectConfigDir(root);
+        const bahulamDir = projectConfigDir(root);
         resource.environment = detectEnvironment();
-        resource.project_context = _readIfExists(keplerDir, 'KEPLER.md', 10000) ||
+        resource.project_context = _readIfExists(bahulamDir, 'KEPLER.md', 10000) ||
             _readIfExists(root, 'KEPLER.md', 10000) ||
-            _readIfExists(keplerDir, 'project.md', 8000);
-        resource.style = _readIfExists(keplerDir, 'style.md', 4000);
-        resource.goal = _readIfExists(keplerDir, 'goal.md', 2000);
-        resource.plan = _readIfExists(keplerDir, 'plan.md', 6000);
-        resource.skills_index = _scanSkills(keplerDir);
+            _readIfExists(bahulamDir, 'project.md', 8000);
+        resource.style = _readIfExists(bahulamDir, 'style.md', 4000);
+        resource.goal = _readIfExists(bahulamDir, 'goal.md', 2000);
+        resource.plan = _readIfExists(bahulamDir, 'plan.md', 6000);
+        resource.skills_index = _scanSkills(bahulamDir);
 
         if (!resource.project_context) {
             for (const name of ['.bahulam.md', 'AGENTS.md', 'CLAUDE.md']) {
@@ -426,7 +426,7 @@ export class ProjectRegistry {
             throw new Error('get_project_overview requires a project path');
         }
 
-        // LLM sometimes passes shell-escaped paths ("Tarang\ Orca") or paths
+        // LLM sometimes passes shell-escaped paths ("Bahulam") or paths
         // beginning with "~". Normalize defensively so the tool does not bounce
         // back a "not found" error on a path that's correct apart from quoting.
         rawPath = normalizePathInput(rawPath);
@@ -600,7 +600,7 @@ export class ProjectRegistry {
         }
 
         // LLM frequently passes shell-quoted paths copied from a terminal,
-        // e.g. "Tarang\ Orca/src/app/\(kepler\)/page.tsx". Normalize here so
+        // e.g. "Bahulam/src/app/\(kepler\)/page.tsx". Normalize here so
         // every tool benefits, not just get_project_overview.
         rawPath = normalizePathInput(rawPath);
 
@@ -633,7 +633,7 @@ export class ProjectRegistry {
         let containingScratchRoot = containingProject ? null : findScratchRoot(candidate);
 
         // Two reasons to try the unescaped variant:
-        //   (1) candidate is outside every project root (literal "Tarang\ Orca"
+        //   (1) candidate is outside every project root (literal "Bahulam"
         //       does not contain a real project), or
         //   (2) candidate is inside a root but does not exist on disk because
         //       a path segment like "\(kepler\)" only resolves once unescaped.

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/formatter.mjs

@@ -1,5 +1,5 @@
 /**
- * Formatter — Clean terminal output for Tarang events.
+ * Formatter — Clean terminal output for Bahulam events.
  *
  * Style reference: Claude Code screenshot
  *   ◐ Cyan spinner + cyan text for working/thinking
@@ -135,7 +135,7 @@ export class EventFormatter {
         if (!this._lastBlock) return;
         if (compactSame && this._lastBlock === nextBlock) return;
 
-        const mode = String(process.env.KEPLER_BLOCK_SEPARATOR || 'space').toLowerCase();
+        const mode = String(process.env.BAHULAM_BLOCK_SEPARATOR || 'space').toLowerCase();
         if (mode === 'off' || mode === 'none') return;
         if (mode === 'dotted' || mode === 'dots') {
             const cols = Math.max(24, process.stderr.columns || process.stdout.columns || 80);

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/input-dock.mjs

@@ -23,15 +23,15 @@
  *        ...                                                  ← up to MAX_INPUT_ROWS
  *                                                              ← spacer
  *   ══════════════════════════════════════════════════════   ← bottom rule (colored)
- *      deepseek-chat-v3 · Tarang-Orca ⎇ main · turn 4         ← meta row
+ *      deepseek-chat-v3 · Bahulam ⎇ main · turn 4         ← meta row
  *      [Enter] send · [/] commands …                          ← tips row
  *   (one blank row at very bottom for cursor safety)
  *
  * Config:
- *   BAHULAM_INPUT_ROWS_MAX / KEPLER_INPUT_ROWS_MAX   1..12  hard cap on input row growth (default 6)
- *   BAHULAM_TTY_MODE=stable / KEPLER_TTY_MODE=stable        scrollback-safe transcript, no fixed dock
- *   BAHULAM_PLAIN=1 / KEPLER_PLAIN=1                        deterministic no-ANSI output for automation
- *   BAHULAM_FIXED_INPUT=0 / KEPLER_FIXED_INPUT=0             disable dock entirely (fallback readline)
+ *   BAHULAM_INPUT_ROWS_MAX   1..12  hard cap on input row growth (default 6)
+ *   BAHULAM_TTY_MODE=stable         scrollback-safe transcript, no fixed dock
+ *   BAHULAM_PLAIN=1                 deterministic no-ANSI output for automation
+ *   BAHULAM_FIXED_INPUT=0           disable dock entirely (fallback readline)
  */
 
 import { paint, width as visibleWidth } from './palette.mjs';
@@ -214,7 +214,7 @@ function inputTextBudget() {
 function resolveMaxInputRows(requested) {
   const raw = requested != null
     ? requested
-    : (process.env.BAHULAM_INPUT_ROWS_MAX || process.env.KEPLER_INPUT_ROWS_MAX);
+    : process.env.BAHULAM_INPUT_ROWS_MAX;
   const n = Number.parseInt(String(raw), 10);
   if (!Number.isFinite(n)) return DEFAULT_MAX_INPUT_ROWS;
   return Math.max(MIN_INPUT_ROWS, Math.min(MAX_INPUT_ROWS_CAP, n));
@@ -530,7 +530,7 @@ export function mountInputDock({
   const t = term();
   if (!t.isTTY || t.plain) return false;
   if (t.ttyMode !== 'rich' || t.fixedInput === false) return false;
-  if (process.env.BAHULAM_FIXED_INPUT === '0' || process.env.KEPLER_FIXED_INPUT === '0') return false;
+  if (process.env.BAHULAM_FIXED_INPUT === '0') return false;
   if (mounted) return true;
 
   inputRowsMax = resolveMaxInputRows(requestedMax);

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