@bahulam/code 2.6.0

package/src/core/mode-selector.mjs

@@ -0,0 +1,51 @@
+/**
+ * Mode Selector
+ *
+ * remote (default): All requests go to Tarang backend.
+ *   Backend handles orchestration, model selection, tool routing.
+ *   User's provider and models configured via web Settings page.
+ *
+ * local: For local LLMs (Ollama, LM Studio, etc.)
+ *   Direct API call, no backend. Only when user explicitly opts in.
+ */
+
+let _probeCache = { available: null, timestamp: 0 };
+const PROBE_CACHE_TTL = 60_000; // 60s
+
+export async function selectMode(instruction, options, config) {
+    // Explicit --local flag: user wants local LLM
+    if (options.local) return 'local';
+
+    // Everything else goes to the backend
+    return 'remote';
+}
+
+export async function probeBackend(url) {
+    if (!url) return false;
+    const now = Date.now();
+    if (_probeCache.available !== null && (now - _probeCache.timestamp) < PROBE_CACHE_TTL) {
+        return _probeCache.available;
+    }
+    try {
+        const resp = await fetch(`${url}/health`, { signal: AbortSignal.timeout(2000) });
+        _probeCache = { available: resp.ok, timestamp: now };
+        return resp.ok;
+    } catch {
+        _probeCache = { available: false, timestamp: now };
+        return false;
+    }
+}
+
+export function classifyTask(instruction) {
+    if (!instruction) return 'simple';
+    const isSimple = SIMPLE_PATTERNS.some(p => p.test(instruction));
+    const isComplex = COMPLEX_PATTERNS.some(p => p.test(instruction));
+    if (isComplex && !isSimple) return 'complex';
+    if (isSimple && !isComplex) return 'simple';
+    return 'medium'; // ambiguous → default to remote when available
+}
+
+/** Reset probe cache (for testing). */
+export function resetProbeCache() {
+    _probeCache = { available: null, timestamp: 0 };
+}

package/src/core/output-filter.mjs

@@ -0,0 +1,177 @@
+/**
+ * Output Filter — Smart shell output filtering + auto-lint.
+ * Ported from tarang-cli (Python) ws/executor.py with enhanced patterns.
+ */
+
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { execSync } from 'node:child_process';
+
+// ── Command Classification ──────────────────────────────────
+
+const COMMAND_PROFILES = {
+    install: {
+        patterns: [/pip install/i, /npm install/i, /yarn add/i, /pnpm add/i, /cargo add/i, /go get/i, /brew install/i, /apt install/i],
+        successLimit: 500,
+        failureLimit: 2000,
+        noisePatterns: [
+            /^Collecting \S+/,
+            /^Downloading \S+/,
+            /^Installing collected/,
+            /^Successfully installed/,
+            /^━+/,                          // Progress bars
+            /^\s*\d+%\s*\|/,              // Percentage bars
+            /^Using cached/,
+            /^Requirement already satisfied/,
+            /^added \d+ packages?/,
+            /^up to date/,
+            /^npm WARN/,
+            /^npm notice/,
+            /^\s*$/,                        // Empty lines
+        ],
+        keepPatterns: [/error/i, /failed/i, /WARN(?:ING)?/i, /not found/i, /permission denied/i],
+    },
+    test: {
+        patterns: [/pytest/i, /npm test/i, /cargo test/i, /go test/i, /jest/i, /vitest/i, /mocha/i],
+        successLimit: 2000,
+        failureLimit: 8000,
+        noisePatterns: [
+            /^\.+$/,                        // Lines of dots (pytest progress)
+            /^PASSED/,
+            /^\s*✓/,                        // Checkmarks
+            /^\s*$/,
+        ],
+        keepPatterns: [/FAILED/i, /FAIL/i, /Error/i, /AssertionError/i, /Expected/i, /Actual/i, /✗/, /✘/],
+    },
+    build: {
+        patterns: [/npm run build/i, /cargo build/i, /go build/i, /tsc/i, /webpack/i, /vite build/i, /make\b/i, /next build/i],
+        successLimit: 1000,
+        failureLimit: 6000,
+        noisePatterns: [
+            /^Compiling \S+/,
+            /^Finished \S+ target/,
+            /^\s*$/,
+        ],
+        keepPatterns: [/error/i, /warning/i],
+    },
+    run: {
+        patterns: [/python\s/i, /node\s/i, /go run/i, /cargo run/i, /npm start/i, /npm run dev/i],
+        successLimit: 4000,
+        failureLimit: 8000,
+        noisePatterns: [],
+        keepPatterns: [],
+    },
+    default: {
+        patterns: [],
+        successLimit: 3000,
+        failureLimit: 6000,
+        noisePatterns: [/^\s*$/],
+        keepPatterns: [],
+    },
+};
+
+/** Detect shell command type for smart filtering. */
+export function detectCommandType(command) {
+    if (!command) return 'default';
+    for (const [type, profile] of Object.entries(COMMAND_PROFILES)) {
+        if (type === 'default') continue;
+        if (profile.patterns.some(p => p.test(command))) return type;
+    }
+    return 'default';
+}
+
+// ── Output Filtering ────────────────────────────────────────
+
+/**
+ * Filter shell output based on command type.
+ * Reduces noise from install/build while preserving errors and useful output.
+ *
+ * @param {string} output - Raw shell output
+ * @param {string} command - The command that was run
+ * @param {boolean} success - Whether the command succeeded
+ * @returns {{ output: string, commandType: string, truncated: boolean, originalLines: number, filteredLines: number }}
+ */
+export function filterOutput(output, command, success = true) {
+    if (!output) return { output: '', commandType: 'default', truncated: false, originalLines: 0, filteredLines: 0 };
+
+    const type = detectCommandType(command);
+    const profile = COMMAND_PROFILES[type];
+    const limit = success ? profile.successLimit : profile.failureLimit;
+    const lines = output.split('\n');
+    const originalLines = lines.length;
+
+    let filteredLines = [];
+
+    for (const line of lines) {
+        // Always keep lines matching keep patterns (errors, failures)
+        const shouldKeep = profile.keepPatterns.length > 0 &&
+            profile.keepPatterns.some(p => p.test(line));
+
+        // Filter out noise patterns
+        const isNoise = !shouldKeep && profile.noisePatterns.length > 0 &&
+            profile.noisePatterns.some(p => p.test(line));
+
+        if (shouldKeep || !isNoise) {
+            filteredLines.push(line);
+        }
+    }
+
+    let filteredOutput = filteredLines.join('\n');
+    let truncated = false;
+
+    // Truncate to limit
+    if (filteredOutput.length > limit) {
+        filteredOutput = filteredOutput.slice(0, limit);
+        const lastNewline = filteredOutput.lastIndexOf('\n');
+        if (lastNewline > 0) {
+            filteredOutput = filteredOutput.slice(0, lastNewline);
+        }
+        filteredOutput += '\n... (truncated)';
+        truncated = true;
+    }
+
+    return {
+        output: filteredOutput,
+        commandType: type,
+        truncated,
+        originalLines,
+        filteredLines: filteredLines.length,
+    };
+}
+
+// ── Auto-Lint ───────────────────────────────────────────────
+
+/** Auto-lint a file after write/edit. Returns lint output or null. */
+export function autoLint(filePath) {
+    if (!filePath || !fs.existsSync(filePath)) return null;
+    const ext = path.extname(filePath);
+    let cmd;
+
+    try {
+        switch (ext) {
+            case '.py':
+                cmd = `python3 -m py_compile "${filePath}" 2>&1`;
+                break;
+            case '.js': case '.mjs': case '.cjs':
+                cmd = `node --check "${filePath}" 2>&1`;
+                break;
+            case '.ts': case '.tsx':
+                if (fs.existsSync('node_modules/.bin/tsc'))
+                    cmd = `npx tsc --noEmit --pretty "${filePath}" 2>&1`;
+                break;
+            case '.go':
+                cmd = `go vet "${filePath}" 2>&1`;
+                break;
+            case '.rs':
+                cmd = `rustfmt --check "${filePath}" 2>&1`;
+                break;
+        }
+
+        if (!cmd) return null;
+        const output = execSync(cmd, { stdio: 'pipe', timeout: 15_000, encoding: 'utf-8' });
+        return output.trim() || null;
+    } catch (err) {
+        const output = (err.stderr || err.stdout || '').toString().trim();
+        return output || null;
+    }
+}

package/src/core/paths.mjs

@@ -0,0 +1,190 @@
+/**
+ * Bahulam Code Paths — centralized path resolution for all CLI data.
+ *
+ * Everything lives under ~/.bahulam/:
+ *   ~/.bahulam/
+ *     config.json              — auth credentials + settings
+ *     history.jsonl            — prompt history
+ *     hooks.json               — global hooks
+ *     conversations/           — conversation JSONL files
+ *     projects/
+ *       {hash}/                — per-project data (hash of project path)
+ *         index/               — BM25 search index
+ *         checkpoints/         — file undo checkpoints
+ *         state.json           — current session state
+ *         sessions/            — session metadata archive
+ *         hooks.json           — project-specific hooks
+ *     projects.json            — slug → project path mapping
+ *
+ * ── Legacy fallback ─────────────────────────────────────────────────────
+ * Pre-rename installs stored everything under ~/.kepler/. The resolver below
+ * prefers the new path but falls back to the legacy directory when it
+ * exists and the new one doesn't, so existing users keep their config,
+ * agents, workflows, and history until they explicitly migrate.
+ *
+ * Env vars:
+ *   BAHULAM_HOME  preferred; explicit override for ~/.bahulam
+ *   KEPLER_HOME   legacy; still honored for backward compat
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import * as crypto from 'node:crypto';
+
+const NEW_HOME_NAME = '.bahulam';
+const LEGACY_HOME_NAME = '.kepler';
+
+let _legacyNoticeShown = false;
+
+/**
+ * Resolve the CLI home directory. Priority:
+ *   1. $BAHULAM_HOME (explicit new)
+ *   2. $KEPLER_HOME  (explicit legacy — prints a one-time deprecation notice)
+ *   3. ~/.bahulam    (if it exists)
+ *   4. ~/.kepler     (if it exists — prints a one-time migration hint)
+ *   5. ~/.bahulam    (fresh install, will be created on first write)
+ */
+function resolveHome() {
+  if (process.env.BAHULAM_HOME) return process.env.BAHULAM_HOME;
+  if (process.env.KEPLER_HOME) {
+    maybeNoticeLegacyEnv();
+    return process.env.KEPLER_HOME;
+  }
+  const home = os.homedir();
+  const newPath = path.join(home, NEW_HOME_NAME);
+  const legacyPath = path.join(home, LEGACY_HOME_NAME);
+  try {
+    if (fs.existsSync(newPath)) return newPath;
+  } catch {}
+  try {
+    if (fs.existsSync(legacyPath)) {
+      maybeNoticeLegacyDir(legacyPath, newPath);
+      return legacyPath;
+    }
+  } catch {}
+  return newPath;
+}
+
+function maybeNoticeLegacyEnv() {
+  if (_legacyNoticeShown || process.env.B0_QUIET_MIGRATION === '1') return;
+  _legacyNoticeShown = true;
+  try {
+    process.stderr.write(
+      '  \x1b[2mnote: KEPLER_HOME is deprecated; set BAHULAM_HOME instead.\x1b[0m\n'
+    );
+  } catch {}
+}
+
+function maybeNoticeLegacyDir(legacyPath, newPath) {
+  if (_legacyNoticeShown || process.env.B0_QUIET_MIGRATION === '1') return;
+  _legacyNoticeShown = true;
+  try {
+    process.stderr.write(
+      `  \x1b[2mnote: reading legacy ${legacyPath}. Move to ${newPath} when convenient (silence with B0_QUIET_MIGRATION=1).\x1b[0m\n`
+    );
+  } catch {}
+}
+
+/**
+ * Hash a project path to a short directory name.
+ * Uses first 16 chars of SHA-256 (same as Claude Code).
+ */
+export function projectHash(projectDir) {
+    // Resolve symlinks (macOS: /tmp → /private/tmp) so the hash is stable
+    let resolved = projectDir;
+    try {
+        resolved = fs.realpathSync(projectDir);
+    } catch {
+        // realpathSync fails if path doesn't exist yet — use as-is
+    }
+    return crypto.createHash('sha256')
+        .update(resolved)
+        .digest('hex')
+        .slice(0, 16);
+}
+
+/** Root ~/.bahulam/ directory (or legacy ~/.kepler/ if that's what's present). */
+export function bahulamHome() {
+    return resolveHome();
+}
+
+/** Backward-compat alias. Prefer `bahulamHome()` in new code. */
+export const keplerHome = bahulamHome;
+
+/** ~/.bahulam/projects/{hash}/ for a given project path. */
+export function projectDir(projectPath) {
+    return path.join(bahulamHome(), 'projects', projectHash(projectPath));
+}
+
+/** ~/.bahulam/projects/{hash}/index/ — BM25 search index. */
+export function indexDir(projectPath) {
+    return path.join(projectDir(projectPath), 'index');
+}
+
+/** ~/.bahulam/projects/{hash}/checkpoints/ — file undo. */
+export function checkpointsDir(projectPath) {
+    return path.join(projectDir(projectPath), 'checkpoints');
+}
+
+/** ~/.bahulam/projects/{hash}/state.json — current session. */
+export function statePath(projectPath) {
+    return path.join(projectDir(projectPath), 'state.json');
+}
+
+/** ~/.bahulam/projects/{hash}/sessions/ — session archive. */
+export function sessionsDir(projectPath) {
+    return path.join(projectDir(projectPath), 'sessions');
+}
+
+/** ~/.bahulam/projects/{hash}/hooks.json — project hooks. */
+export function projectHooksPath(projectPath) {
+    return path.join(projectDir(projectPath), 'hooks.json');
+}
+
+/** ~/.bahulam/conversations/ — central conversation storage. */
+export function conversationsDir() {
+    return path.join(bahulamHome(), 'conversations');
+}
+
+/** ~/.bahulam/conversations/{sessionId}.jsonl */
+export function conversationPath(sessionId) {
+    return path.join(conversationsDir(), `${sessionId}.jsonl`);
+}
+
+/** ~/.bahulam/hooks.json — global hooks. */
+export function globalHooksPath() {
+    return path.join(bahulamHome(), 'hooks.json');
+}
+
+/** ~/.bahulam/history.jsonl — prompt history. */
+export function historyPath() {
+    return path.join(bahulamHome(), 'history.jsonl');
+}
+
+// ── Project-local config directory (.bahulam/ next to CLAUDE.md/etc) ────
+//
+// Project-scoped stuff (agents/*.yaml, memory/*.md, hooks/, settings.json,
+// tasks/) used to live in .kepler/ inside the project. Same resolver logic
+// applies — prefer .bahulam/, fall back to .kepler/ when only the legacy
+// dir exists.
+
+const PROJECT_NEW_NAME = '.bahulam';
+const PROJECT_LEGACY_NAME = '.kepler';
+
+/**
+ * Resolve the project-local config directory for `cwd`. Same priority as
+ * the home resolver. Returns an absolute path; the directory may not
+ * exist yet (callers that write should mkdir -p first).
+ */
+export function projectConfigDir(cwd = process.cwd()) {
+    const newPath = path.join(cwd, PROJECT_NEW_NAME);
+    const legacyPath = path.join(cwd, PROJECT_LEGACY_NAME);
+    try {
+        if (fs.existsSync(newPath)) return newPath;
+    } catch {}
+    try {
+        if (fs.existsSync(legacyPath)) return legacyPath;
+    } catch {}
+    return newPath;
+}

package/src/core/policy-resolver.mjs

@@ -0,0 +1,156 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+export const DEFAULT_POLICY = Object.freeze({
+  version: 1,
+  context: {
+    loadEveryTurn: ['KEPLER.md', 'project.md', 'style.md', 'goal.md', 'plan.md', 'tasks/*.md'],
+    showReloadNotice: true,
+    injectCommandOptions: true,
+    injectActionableTips: true,
+    tipTtlTurns: 2,
+  },
+  planning: {
+    owner: 'auto',
+    allowedOwners: ['main_agent', 'planner_subagent', 'auto', 'manual'],
+    delegateWhen: {
+      taskCountGte: 4,
+      estimatedFilesGte: 6,
+      touchesMultiplePackages: true,
+    },
+    onUserEditedPlan: 'prefer_user_plan',
+  },
+  tasks: {
+    storage: 'project_markdown',
+    syncTodoWrite: true,
+    resumePrompt: true,
+  },
+  commands: {
+    enabled: ['map', 'probe', 'footprint', 'heal', 'align', 'distill', 'brief', 'rewind'],
+    defaultMode: 'interactive',
+    dryRunDefault: false,
+    suggestions: true,
+    suggestOnlyWhenActionable: true,
+    timeouts: {
+      defaultSeconds: 300,
+      healSeconds: 600,
+      probeSeconds: 180,
+      briefSeconds: 60,
+    },
+    aliases: {
+      fix: 'heal',
+      repair: 'heal',
+      search: 'probe',
+      summarize: 'brief',
+    },
+  },
+  hitl: {
+    defaultScope: 'once',
+    allowSessionTrust: true,
+    allowProjectTrust: false,
+    reaskAfterMinutes: 30,
+    reaskOnCommandShapeChange: true,
+    reaskOnRiskIncrease: true,
+    reaskOnPathBoundaryChange: true,
+    alwaysAskForDangerous: true,
+  },
+  hooks: {
+    timeoutSeconds: 5,
+  },
+  ui: {
+    recentActions: true,
+    verbosity: 'normal',
+  },
+});
+
+export function deepClone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+export function deepMerge(target, source) {
+  if (!source || typeof source !== 'object') return deepClone(target);
+  const result = Array.isArray(target) ? [...target] : { ...(target || {}) };
+  for (const [key, value] of Object.entries(source)) {
+    if (
+      value &&
+      typeof value === 'object' &&
+      !Array.isArray(value) &&
+      result[key] &&
+      typeof result[key] === 'object' &&
+      !Array.isArray(result[key])
+    ) {
+      result[key] = deepMerge(result[key], value);
+    } else {
+      result[key] = deepClone(value);
+    }
+  }
+  return result;
+}
+
+function readJson(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch (err) {
+    return { __error: err.message };
+  }
+}
+
+function projectConfigPath(cwd) {
+  return path.join(cwd, '.bahulam', 'config.json');
+}
+
+function globalPolicyPath() {
+  return path.join(os.homedir(), '.bahulam', 'policy.json');
+}
+
+function flatten(obj, prefix = '', out = []) {
+  for (const [key, value] of Object.entries(obj || {})) {
+    const dotted = prefix ? `${prefix}.${key}` : key;
+    if (value && typeof value === 'object' && !Array.isArray(value)) flatten(value, dotted, out);
+    else out.push([dotted, value]);
+  }
+  return out;
+}
+
+export function loadEffectivePolicy({ cwd = process.cwd(), cli = {}, session = {} } = {}) {
+  const layers = [
+    { name: 'default', path: null, data: deepClone(DEFAULT_POLICY) },
+  ];
+
+  const global = readJson(globalPolicyPath());
+  if (global && !global.__error) layers.push({ name: 'global', path: globalPolicyPath(), data: global });
+  else if (global?.__error) layers.push({ name: 'global', path: globalPolicyPath(), error: global.__error, data: {} });
+
+  const project = readJson(projectConfigPath(cwd));
+  if (project && !project.__error) layers.push({ name: 'project', path: projectConfigPath(cwd), data: project });
+  else if (project?.__error) layers.push({ name: 'project', path: projectConfigPath(cwd), error: project.__error, data: {} });
+
+  if (session && Object.keys(session).length > 0) layers.push({ name: 'session', path: null, data: session });
+  if (cli && Object.keys(cli).length > 0) layers.push({ name: 'cli', path: null, data: cli });
+
+  let policy = {};
+  const sources = {};
+  for (const layer of layers) {
+    policy = deepMerge(policy, layer.data || {});
+    for (const [key, value] of flatten(layer.data || {})) {
+      sources[key] = { source: layer.name, path: layer.path, value };
+    }
+  }
+
+  return { policy, sources, layers };
+}
+
+export function formatPolicySourceRows(effective) {
+  const rows = [];
+  for (const [key, meta] of Object.entries(effective?.sources || {}).sort()) {
+    rows.push({
+      key,
+      source: meta.source,
+      path: meta.path || '',
+      value: meta.value,
+    });
+  }
+  return rows;
+}