@bahulam/code 0.1.5 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bahulam/code",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Bahulam Code \u2014 abundance, in your terminal. CLI-first, reliability-first, sub-agents, 65.6% SWE-bench Verified.",
   "type": "module",
   "bin": {

package/src/core/stream-client.mjs

@@ -76,6 +76,23 @@ function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+function envMs(name, fallback) {
+    const raw = Number(process.env[name] || fallback);
+    return Number.isFinite(raw) && raw > 0 ? raw : fallback;
+}
+
+function transportDebugEnabled() {
+    const raw = String(process.env.BAHULAM_TRANSPORT_DEBUG || '').toLowerCase();
+    return raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on';
+}
+
+function transportDebug(message, data = {}) {
+    if (!transportDebugEnabled()) return;
+    try {
+        process.stderr.write(`[transport] ${message} ${JSON.stringify(data)}\n`);
+    } catch {}
+}
+
 // Full jitter around the scheduled delay: pick a value in [delay*0.5, delay*1.5].
 // Spreads out reconnect storms so N clients dropping simultaneously don't
 // synchronize their retries. Clamped to the same 30s ceiling as the base delay.
@@ -223,6 +240,7 @@ export class TarangStreamClient {
     async *execute(instruction, context = {}, messages = null) {
         this._cancelled = false;
         this.currentTaskId = null;
+        this._firstEventTimedOut = false;
 
         // Bundled mode: spawn the local Python runtime on first turn.
         // After this, this.baseUrl points at http://127.0.0.1:<random-port>
@@ -233,6 +251,7 @@ export class TarangStreamClient {
         const body = { instruction, context };
         if (messages && messages.length > 0) body.messages = messages;
         if (this.sessionId) body.session_id = this.sessionId;
+        const requestId = `cli-${_uuidLike()}`;
 
         // daemon cache-guard hook. If BAHULAM_CAPTURE_REQUEST is set to a file
         // path, serialize the exact body that would go to /api/execute, write
@@ -260,6 +279,8 @@ export class TarangStreamClient {
         const headers = this._headers({
             'Accept': 'text/event-stream',
             'Content-Type': 'application/json',
+            'X-Bahulam-Request-ID': requestId,
+            'X-Request-ID': requestId,
         });
 
         // Abort controller so cancel() can break out of a stalled reader
@@ -268,6 +289,21 @@ export class TarangStreamClient {
         this._toolAbort = new AbortController();
 
         let response;
+        let connectTimedOut = false;
+        const connectTimeoutMs = envMs('BAHULAM_EXECUTE_CONNECT_TIMEOUT_MS', 60_000);
+        const connectStarted = Date.now();
+        const connectTimer = setTimeout(() => {
+            connectTimedOut = true;
+            try { this._abort.abort(); } catch {}
+        }, connectTimeoutMs);
+        transportDebug('execute.start', {
+            request_id: requestId,
+            url,
+            mode: this.mode,
+            session_id: this.sessionId || null,
+            messages: Array.isArray(messages) ? messages.length : 0,
+            body_bytes: Buffer.byteLength(JSON.stringify(body), 'utf8'),
+        });
         try {
             response = await fetch(url, {
                 method: 'POST',
@@ -276,15 +312,39 @@ export class TarangStreamClient {
                 signal: this._abort.signal,
             });
         } catch (err) {
+            clearTimeout(connectTimer);
             if (err.name === 'AbortError') {
+                if (connectTimedOut) {
+                    const message = `Backend did not accept /api/execute within ${Math.round(connectTimeoutMs / 1000)}s (request ${requestId}).`;
+                    transportDebug('execute.connect_timeout', {
+                        request_id: requestId,
+                        ms: Date.now() - connectStarted,
+                    });
+                    yield { type: EVENT_TYPES.ERROR, data: { message, request_id: requestId, fatal: true } };
+                }
                 return;
             }
-            yield { type: EVENT_TYPES.ERROR, data: { message: `Network error: ${err.message}. Check your connection or use --local mode.`, fatal: true } };
+            transportDebug('execute.network_error', {
+                request_id: requestId,
+                ms: Date.now() - connectStarted,
+                error: err.message,
+                code: err?.cause?.code || err?.code || '',
+            });
+            yield { type: EVENT_TYPES.ERROR, data: { message: `Network error: ${err.message}. Check your connection or use --local mode.`, request_id: requestId, fatal: true } };
             return;
         }
+        clearTimeout(connectTimer);
+        const responseRequestId = response.headers.get('x-request-id') || requestId;
+        transportDebug('execute.response', {
+            request_id: responseRequestId,
+            status: response.status,
+            ok: response.ok,
+            ms: Date.now() - connectStarted,
+            task_id: response.headers.get('x-task-id') || null,
+        });
 
         if (response.status === 401) {
-            yield { type: EVENT_TYPES.ERROR, data: { message: 'Authentication failed. Run `bahulam login` to re-authenticate.', fatal: true } };
+            yield { type: EVENT_TYPES.ERROR, data: { message: 'Authentication failed. Run `bahulam login` to re-authenticate.', request_id: responseRequestId, fatal: true } };
             return;
         }
         if (response.status === 429) {
@@ -305,6 +365,7 @@ export class TarangStreamClient {
                     rate_limit: detail?.rate_limit || null,
                     action: detail?.action || null,
                     pricing_url: normalizeBillingBrandCopy(detail?.pricing_url || null),
+                    request_id: responseRequestId,
                     fatal: true,
                 },
             };
@@ -312,7 +373,7 @@ export class TarangStreamClient {
         }
         if (!response.ok) {
             const text = await response.text().catch(() => 'Unknown error');
-            yield { type: EVENT_TYPES.ERROR, data: { message: `Backend error ${response.status}: ${text}`, fatal: true } };
+            yield { type: EVENT_TYPES.ERROR, data: { message: `Backend error ${response.status}: ${text}`, request_id: responseRequestId, fatal: true } };
             return;
         }
 
@@ -322,6 +383,17 @@ export class TarangStreamClient {
             if (this._cancelled) {
                 return;
             }
+            if (this._firstEventTimedOut) {
+                yield {
+                    type: EVENT_TYPES.ERROR,
+                    data: {
+                        message: `Backend opened the stream but sent no SSE events within ${Math.round(envMs('BAHULAM_FIRST_EVENT_TIMEOUT_MS', 60_000) / 1000)}s (request ${responseRequestId}).`,
+                        request_id: responseRequestId,
+                        fatal: true,
+                    },
+                };
+                return;
+            }
             yield* this._reconnectAfterDrop(err);
         }
     }
@@ -330,18 +402,37 @@ export class TarangStreamClient {
         const taskId = response.headers.get('X-Task-ID');
         if (taskId) this.currentTaskId = taskId;
 
-        for await (const parsed of this._parseSSE(response)) {
-            if (this._cancelled) return;
-            await this._waitIfPaused();
-            if (this._cancelled) return;
+        let sawFirstEvent = false;
+        const firstEventTimeoutMs = envMs('BAHULAM_FIRST_EVENT_TIMEOUT_MS', 60_000);
+        const firstEventTimer = setTimeout(() => {
+            if (sawFirstEvent || this._cancelled) return;
+            this._firstEventTimedOut = true;
+            try { this._abort?.abort(); } catch {}
+        }, firstEventTimeoutMs);
+        try {
+            for await (const parsed of this._parseSSE(response)) {
+                if (!sawFirstEvent) {
+                    sawFirstEvent = true;
+                    clearTimeout(firstEventTimer);
+                    transportDebug('execute.first_event', {
+                        task_id: this.currentTaskId || null,
+                        event: parsed.event || null,
+                    });
+                }
+                if (this._cancelled) return;
+                await this._waitIfPaused();
+                if (this._cancelled) return;
 
-            if (parsed.id != null) this.lastEventId = parsed.id;
-            if (parsed.retry != null) this.retryDelayMs = parsed.retry;
-            if (parsed.data?.task_id) this.currentTaskId = parsed.data.task_id;
+                if (parsed.id != null) this.lastEventId = parsed.id;
+                if (parsed.retry != null) this.retryDelayMs = parsed.retry;
+                if (parsed.data?.task_id) this.currentTaskId = parsed.data.task_id;
 
-            for await (const event of this._handleStreamEvent(parsed)) {
-                yield event;
+                for await (const event of this._handleStreamEvent(parsed)) {
+                    yield event;
+                }
             }
+        } finally {
+            clearTimeout(firstEventTimer);
         }
     }
 

package/src/core/tool-executor.mjs

@@ -44,6 +44,8 @@ export function createToolExecutor({
     checkpoints = null,
     hookRunner = null,
     interactionHandler = null,
+    onAutoRegisterStart = null,
+    onAutoRegisterDone = null,
 } = {}) {
     // Cross-session memory cache. Ships in getAgentContext() on every turn,
     // so we need it to be byte-identical when the underlying disk file hasn't
@@ -94,9 +96,19 @@ export function createToolExecutor({
     // for the current directory to be usable — the user chose to be here.
     // Opt out via BAHULAM_SKIP_AUTO_REGISTER=true for tests or headless
     // scripts that want a truly empty registry.
+    let autoRegisterPromise = Promise.resolve(null);
     if (process.env.BAHULAM_SKIP_AUTO_REGISTER !== 'true') {
-        projectRegistry.register(process.cwd(), { bypassProjectMarkers: true })
-            .catch(() => { /* silent — model can register explicitly */ });
+        const autoRegisterRoot = process.cwd();
+        try { onAutoRegisterStart?.(autoRegisterRoot); } catch { /* status hooks are best-effort */ }
+        autoRegisterPromise = projectRegistry.register(autoRegisterRoot, { bypassProjectMarkers: true })
+            .then((result) => {
+                try { onAutoRegisterDone?.(null, result); } catch { /* status hooks are best-effort */ }
+                return result;
+            })
+            .catch((err) => {
+                try { onAutoRegisterDone?.(err, null); } catch { /* status hooks are best-effort */ }
+                return null;
+            });
     }
     let _searchCodeUsed = false; // tracks if search_code was called (for read_file nudge)
     let _readOnlyCacheGeneration = 0;
@@ -2203,6 +2215,10 @@ print('OK: replaced')
             return projectRegistry.resources();
         },
 
+        waitForAutoRegister() {
+            return autoRegisterPromise;
+        },
+
         async registerProjectRoots(roots, { forceRefresh = false } = {}) {
             const results = [];
             const seen = new Set();

package/src/terminal/repl.mjs

@@ -74,6 +74,7 @@ import { buildResumeHistory, combineResumeSummaries, getRecentSessions, getSessi
 import { decideResumeMode, projectedTokensForChoice, formatTokens as formatCtxTokens } from '../core/resume-mode.mjs';
 import { appendTask, ensureTaskFiles, loadTaskBoard, moveTask, removeTask, taskCounts, TASK_FILES, updateTask } from '../core/tasks.mjs';
 import { applyCompactSummary, localCompactSummary, parseCompactTailCount, prepareCompactHistory } from '../core/compact-history.mjs';
+import { startSpinner as startInlineSpinner } from '../ui/spinner.mjs';
 import {
   appendVisionAnalysisToInstruction,
   appendDocumentsToInstruction,
@@ -3674,7 +3675,28 @@ export async function startTerminalRepl() {
     return res;
   };
 
-  let toolExecutor = createToolExecutor({ checkpoints, hookRunner, interactionHandler: askUserInteraction });
+  function makeToolExecutor({ showIndexStatus = false } = {}) {
+    const shouldShowIndexStatus = showIndexStatus && process.stderr.isTTY && !term().plain;
+    let stopIndexSpinner = null;
+    return createToolExecutor({
+      checkpoints,
+      hookRunner,
+      interactionHandler: askUserInteraction,
+      onAutoRegisterStart: shouldShowIndexStatus ? (root) => {
+        const name = path.basename(root || safeCwd()) || root || 'project';
+        stopIndexSpinner?.();
+        stopIndexSpinner = startInlineSpinner(
+          `Indexing ${name} so tools can read and search this project...`
+        );
+      } : null,
+      onAutoRegisterDone: shouldShowIndexStatus ? () => {
+        stopIndexSpinner?.();
+        stopIndexSpinner = null;
+      } : null,
+    });
+  }
+
+  let toolExecutor = makeToolExecutor({ showIndexStatus: true });
   const skipPerms = cliArgs.skipPermissions;
   let approval = new ApprovalManager({ autoApprove: skipPerms, cwd: safeCwd(), policy: effectivePolicy.policy });
 
@@ -3768,7 +3790,7 @@ export async function startTerminalRepl() {
     checkpoints = new CheckpointManager(safeCwd());
     effectivePolicy = loadEffectivePolicy({ cwd: safeCwd() });
     hookRunner = new HookRunner({ cwd: safeCwd() });
-    toolExecutor = createToolExecutor({ checkpoints, hookRunner, interactionHandler: askUserInteraction });
+    toolExecutor = makeToolExecutor();
     approval = new ApprovalManager({ autoApprove: skipPerms, cwd: safeCwd(), policy: effectivePolicy.policy });
     if (ctx._rl) approval.setReadline(ctx._rl);
     sessionMgr = new SessionManager(safeCwd());
@@ -3948,7 +3970,7 @@ export async function startTerminalRepl() {
     checkpoints = new CheckpointManager(safeCwd());
     effectivePolicy = loadEffectivePolicy({ cwd: safeCwd() });
     hookRunner = new HookRunner({ cwd: safeCwd(), sessionId });
-    toolExecutor = createToolExecutor({ checkpoints, hookRunner, interactionHandler: askUserInteraction });
+    toolExecutor = makeToolExecutor();
     approval = new ApprovalManager({ autoApprove: skipPerms, cwd: safeCwd(), policy: effectivePolicy.policy });
     if (ctx._rl) approval.setReadline(ctx._rl);
     sessionMgr = new SessionManager(safeCwd());

package/src/tools/project-overview.mjs

@@ -54,6 +54,10 @@ const IGNORED_DIRS = new Set([
     '.git', '.bahulam', '.next', '.venv', '__pycache__',
     'build', 'dist', 'node_modules', 'venv',
 ]);
+const ENV_PROBE_TIMEOUT_MS = Math.max(
+    50,
+    Number(process.env.BAHULAM_ENV_PROBE_TIMEOUT_MS || 500) || 500,
+);
 
 // Files or directories whose presence at the root implies this IS a project.
 // One is enough. Kept broad so we accept Node/Python/Rust/Go/Ruby/Java/C++
@@ -227,7 +231,7 @@ function commandVersion(command, args = ['--version']) {
     try {
         const result = spawnSync(command, args, {
             encoding: 'utf-8',
-            timeout: 2000,
+            timeout: ENV_PROBE_TIMEOUT_MS,
             windowsHide: true,
         });
         if (result.error || result.status !== 0) return '';
@@ -244,7 +248,6 @@ function detectEnvironment() {
         ['git', 'git'],
         ['npm', 'npm'],
         ['uv', 'uv'],
-        ['pytest', 'pytest'],
         ['docker', 'docker'],
     ];
     const tools = {};