@bahulam/code 0.1.7 → 0.1.9

package/src/core/local-store.mjs

@@ -12,6 +12,100 @@ import { bahulamHome } from './paths.mjs';
 
 const KEPLER_DIR = bahulamHome();
 const PROJECTS_DIR = path.join(KEPLER_DIR, 'projects');
+const REPLAY_EVENT_RECORD_TYPES = new Set(['bahulam_event', 'kepler_event']);
+
+function finiteNumber(value) {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+
+function firstFiniteNumber(...values) {
+  for (const value of values) {
+    const n = finiteNumber(value);
+    if (n !== null) return n;
+  }
+  return 0;
+}
+
+function replayEventFromRecord(record) {
+  if (!record || !REPLAY_EVENT_RECORD_TYPES.has(record.type) || !record.event) return null;
+  const event = record.event;
+  if (!event || typeof event !== 'object' || !event.type) return null;
+  return {
+    ...event,
+    data: event.data && typeof event.data === 'object' ? event.data : {},
+  };
+}
+
+function eventUsage(event) {
+  const data = event?.data && typeof event.data === 'object' ? event.data : {};
+  const usage = data.usage && typeof data.usage === 'object' ? data.usage : null;
+  if (!usage) return null;
+  return usage;
+}
+
+function usageTotals(usage = {}) {
+  return {
+    inputTokens: firstFiniteNumber(usage.total_input_tokens, usage.input_tokens, usage.prompt_tokens),
+    outputTokens: firstFiniteNumber(usage.total_output_tokens, usage.output_tokens, usage.completion_tokens),
+    cacheReadTokens: firstFiniteNumber(usage.cache_read_input_tokens, usage.cache_read_tokens, usage.cache_read),
+    cacheCreationTokens: firstFiniteNumber(usage.cache_creation_input_tokens, usage.cache_creation_tokens, usage.cache_creation),
+    reasoningTokens: firstFiniteNumber(usage.reasoning_tokens),
+  };
+}
+
+function addModelUsage(meta, modelSet, usage = {}) {
+  if (!Array.isArray(usage.models)) return;
+  for (const item of usage.models) {
+    const model = typeof item === 'string' ? item : item?.model;
+    if (typeof model === 'string' && model) modelSet.add(model);
+    if (!model || typeof item !== 'object') continue;
+    if (!meta.modelUsage[model]) {
+      meta.modelUsage[model] = {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        reasoningTokens: 0,
+        costUsd: 0,
+      };
+    }
+    const totals = usageTotals(item);
+    meta.modelUsage[model].inputTokens += totals.inputTokens;
+    meta.modelUsage[model].outputTokens += totals.outputTokens;
+    meta.modelUsage[model].cacheReadTokens += totals.cacheReadTokens;
+    meta.modelUsage[model].cacheCreationTokens += totals.cacheCreationTokens;
+    meta.modelUsage[model].reasoningTokens += totals.reasoningTokens;
+    meta.modelUsage[model].costUsd += firstFiniteNumber(item.cost_usd, item.cost);
+  }
+}
+
+function addUsageTotals(meta, modelSet, usage = {}) {
+  const totals = usageTotals(usage);
+  meta.inputTokens += totals.inputTokens;
+  meta.outputTokens += totals.outputTokens;
+  meta.cacheReadTokens += totals.cacheReadTokens;
+  meta.cacheCreationTokens += totals.cacheCreationTokens;
+  meta.reasoningTokens += totals.reasoningTokens;
+  addModelUsage(meta, modelSet, usage);
+}
+
+function assistantHasMatchingComplete(assistantRecord, completeRecords) {
+  return completeRecords.some((record) => {
+    const distance = Math.abs(Number(assistantRecord.order) - Number(record.order));
+    return distance > 0 && distance <= 3;
+  });
+}
+
+function applyUsageRecords(meta, modelSet, records) {
+  const completeRecords = records.filter(record => record.source === 'complete');
+  for (const record of completeRecords) addUsageTotals(meta, modelSet, record.usage);
+  for (const record of records) {
+    if (record.source !== 'assistant') continue;
+    if (assistantHasMatchingComplete(record, completeRecords)) continue;
+    addUsageTotals(meta, modelSet, record.usage);
+  }
+}
 
 function normalizeBlock(block) {
   if (!block || typeof block !== 'object') {
@@ -188,8 +282,10 @@ async function parseSessionMeta(filePath) {
     outputTokens: 0,
     cacheReadTokens: 0,
     cacheCreationTokens: 0,
+    reasoningTokens: 0,
     toolCalls: [],   // [{name, count}]
     models: [],      // [model strings]
+    modelUsage: {},   // model -> token/cost totals from complete events
     modelLimits: {},  // role -> {model, context_length, max_output, source}
     subAgentModels: {}, // role -> model from backend session_info
     startTime: null,
@@ -207,6 +303,7 @@ async function parseSessionMeta(filePath) {
 
   const toolCounts = {};
   const modelSet = new Set();
+  const usageRecords = [];
 
   // endStatus tracking
   let lastMessageRole = null;
@@ -218,8 +315,10 @@ async function parseSessionMeta(filePath) {
 
     const fileStream = fs.createReadStream(filePath, { encoding: 'utf-8' });
     const rl = readline.createInterface({ input: fileStream, crlfDelay: Infinity });
+    let lineOrder = 0;
 
     for await (const line of rl) {
+      const recordOrder = lineOrder++;
       if (!line.trim()) continue;
       let obj;
       try { obj = JSON.parse(line); }
@@ -235,13 +334,30 @@ async function parseSessionMeta(filePath) {
         if (!meta.endTime || ts > meta.endTime) meta.endTime = ts;
       }
 
-      // Backend kepler_event payloads may carry cost / error markers.
-      if (obj.type === 'kepler_event' && obj.event) {
-        const ev = obj.event;
-        if (ev.type === 'complete' && typeof ev.cost_usd === 'number') meta.costUsd += ev.cost_usd;
+      // Bahulam replay events may carry cost / error markers. Older local
+      // transcripts used the same payload under the legacy kepler_event type.
+      const ev = replayEventFromRecord(obj);
+      if (ev) {
+        const data = ev.data || {};
+        if (ev.type === 'complete') {
+          const usage = eventUsage(ev);
+          if (usage) {
+            usageRecords.push({ source: 'complete', order: recordOrder, usage });
+          }
+          const eventCost = firstFiniteNumber(
+            data.cost_usd,
+            data.total_cost_usd,
+            data.total_cost,
+            data.usage?.total_cost_usd,
+            data.usage?.total_cost,
+            data.usage?.cost,
+            ev.cost_usd,
+          );
+          if (eventCost) meta.costUsd += eventCost;
+        }
         if (ev.type === 'session_info') {
-          if (typeof ev.total_cost_usd === 'number') meta.costUsd = ev.total_cost_usd;
-          const info = ev.data || ev;
+          if (typeof data.total_cost_usd === 'number') meta.costUsd = data.total_cost_usd;
+          const info = data;
           if (info.model_limits && typeof info.model_limits === 'object') {
             meta.modelLimits = info.model_limits;
           }
@@ -255,15 +371,15 @@ async function parseSessionMeta(filePath) {
           }
         }
         if (ev.type === 'error' || ev.error === true) hadError = true;
-        if (ev.type === 'resume_summary' && typeof ev.data?.summary === 'string') {
+        if (ev.type === 'resume_summary' && typeof data.summary === 'string') {
           meta.resumeSummary = {
-            sourceMessageCount: Number(ev.data.source_message_count) || 0,
-            previousSourceMessageCount: Number(ev.data.previous_source_message_count) || 0,
-            fullMessageCount: Number(ev.data.full_message_count) || 0,
-            summaryChars: ev.data.summary.length,
-            summarySource: ev.data.summary_source || '',
-            mode: ev.data.mode || '',
-            modeLabel: ev.data.mode_label || '',
+            sourceMessageCount: Number(data.source_message_count) || 0,
+            previousSourceMessageCount: Number(data.previous_source_message_count) || 0,
+            fullMessageCount: Number(data.full_message_count) || 0,
+            summaryChars: data.summary.length,
+            summarySource: data.summary_source || '',
+            mode: data.mode || '',
+            modeLabel: data.mode_label || '',
             timestamp: obj.timestamp || null,
           };
         }
@@ -296,10 +412,7 @@ async function parseSessionMeta(filePath) {
         lastMessageRole = 'assistant';
         const usage = obj.message?.usage;
         if (usage) {
-          meta.inputTokens += usage.input_tokens || 0;
-          meta.outputTokens += usage.output_tokens || 0;
-          meta.cacheReadTokens += usage.cache_read_input_tokens || 0;
-          meta.cacheCreationTokens += usage.cache_creation_input_tokens || 0;
+          usageRecords.push({ source: 'assistant', order: recordOrder, usage });
         }
         const model = obj.message?.model;
         if (model) modelSet.add(model);
@@ -322,6 +435,8 @@ async function parseSessionMeta(filePath) {
     .map(([name, count]) => ({ name, count }))
     .sort((a, b) => b.count - a.count);
   meta.models = [...modelSet];
+  applyUsageRecords(meta, modelSet, usageRecords);
+  meta.models = [...modelSet];
 
   // Projected context size for resume should estimate the serialized payload,
   // not cumulative provider usage. Provider input tokens are charged per turn
@@ -393,11 +508,12 @@ export async function getSessionDetail(sessionId, options = {}) {
     }
     const entryOrder = order++;
 
-    if (obj.type === 'kepler_event' && obj.event?.type) {
+    const replayEvent = replayEventFromRecord(obj);
+    if (replayEvent) {
       replayEvents.push({
         order: entryOrder,
         timestamp: obj.timestamp || null,
-        event: obj.event,
+        event: replayEvent,
       });
       continue;
     }
@@ -765,6 +881,7 @@ export async function getSessionStats(days = 30) {
     totalInputTokens: 0,
     totalOutputTokens: 0,
     totalCacheReadTokens: 0,
+    totalReasoningTokens: 0,
     totalToolCalls: 0,
     toolBreakdown: {},
     modelBreakdown: {},
@@ -777,13 +894,44 @@ export async function getSessionStats(days = 30) {
     stats.totalInputTokens += meta.inputTokens;
     stats.totalOutputTokens += meta.outputTokens;
     stats.totalCacheReadTokens += meta.cacheReadTokens;
+    stats.totalReasoningTokens += meta.reasoningTokens;
 
     for (const tc of meta.toolCalls) {
       stats.toolBreakdown[tc.name] = (stats.toolBreakdown[tc.name] || 0) + tc.count;
       stats.totalToolCalls += tc.count;
     }
     for (const model of meta.models) {
-      stats.modelBreakdown[model] = (stats.modelBreakdown[model] || 0) + 1;
+      if (!stats.modelBreakdown[model]) {
+        stats.modelBreakdown[model] = {
+          sessions: 0,
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheReadTokens: 0,
+          cacheCreationTokens: 0,
+          reasoningTokens: 0,
+          costUsd: 0,
+        };
+      }
+      stats.modelBreakdown[model].sessions += 1;
+    }
+    for (const [model, usage] of Object.entries(meta.modelUsage || {})) {
+      if (!stats.modelBreakdown[model]) {
+        stats.modelBreakdown[model] = {
+          sessions: 0,
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheReadTokens: 0,
+          cacheCreationTokens: 0,
+          reasoningTokens: 0,
+          costUsd: 0,
+        };
+      }
+      stats.modelBreakdown[model].inputTokens += usage.inputTokens || 0;
+      stats.modelBreakdown[model].outputTokens += usage.outputTokens || 0;
+      stats.modelBreakdown[model].cacheReadTokens += usage.cacheReadTokens || 0;
+      stats.modelBreakdown[model].cacheCreationTokens += usage.cacheCreationTokens || 0;
+      stats.modelBreakdown[model].reasoningTokens += usage.reasoningTokens || 0;
+      stats.modelBreakdown[model].costUsd += usage.costUsd || 0;
     }
   }
 
@@ -808,8 +956,8 @@ export async function getToolBreakdown(days = 30) {
 export async function getModelBreakdown(days = 30) {
   const stats = await getSessionStats(days);
   return Object.entries(stats.modelBreakdown)
-    .map(([model, sessions]) => ({ model, sessions }))
-    .sort((a, b) => b.sessions - a.sessions);
+    .map(([model, usage]) => ({ model, ...usage }))
+    .sort((a, b) => b.sessions - a.sessions || (b.inputTokens + b.outputTokens) - (a.inputTokens + a.outputTokens));
 }
 
 /**
@@ -833,7 +981,7 @@ export function getHistory(n = 50) {
 
 export function getStorePaths() {
   return {
-    keplerDir: KEPLER_DIR,
+    bahulamDir: KEPLER_DIR,
     projectsDir: PROJECTS_DIR,
     historyPath: path.join(KEPLER_DIR, 'history.jsonl'),
   };

package/src/core/mode-selector.mjs

@@ -1,7 +1,7 @@
 /**
  * Mode Selector
  *
- * remote (default): All requests go to Tarang backend.
+ * remote (default): All requests go to Bahulam backend.
  *   Backend handles orchestration, model selection, tool routing.
  *   User's provider and models configured via web Settings page.
  *

package/src/core/output-filter.mjs

@@ -1,6 +1,6 @@
 /**
  * Output Filter — Smart shell output filtering + auto-lint.
- * Ported from tarang-cli (Python) ws/executor.py with enhanced patterns.
+ * Ported from tarang-cli (Python, legacy) ws/executor.py with enhanced patterns.
  */
 
 import * as fs from 'node:fs';

package/src/core/project-artifacts.mjs

@@ -23,9 +23,9 @@ export function persistProjectArtifacts(data, resources, log = () => {}) {
         for (const [field, filename] of artifacts) {
             try {
                 // Resolver honors legacy .kepler/ when it's the only dir that exists.
-                const keplerDir = projectConfigDir(resource.root);
-                fs.mkdirSync(keplerDir, { recursive: true });
-                const artifactPath = path.join(keplerDir, filename);
+                const bahulamDir = projectConfigDir(resource.root);
+                fs.mkdirSync(bahulamDir, { recursive: true });
+                const artifactPath = path.join(bahulamDir, filename);
                 fs.writeFileSync(artifactPath, data[field], 'utf-8');
                 resource[field] = data[field];
                 written.push(artifactPath);

package/src/core/project-context-loader.mjs

@@ -1,7 +1,7 @@
 import * as crypto from 'node:crypto';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { loadKeplerMemory } from '../config/memory-loader.mjs';
+import { loadBahulamMemory } from '../config/memory-loader.mjs';
 import { bahulamHome, projectConfigDir } from './paths.mjs';
 
 function sha(content) {
@@ -27,8 +27,8 @@ function readFile(filePath, label, maxChars = 12000) {
   }
 }
 
-function readTasks(keplerDir) {
-  const tasksDir = path.join(keplerDir, 'tasks');
+function readTasks(bahulamDir) {
+  const tasksDir = path.join(bahulamDir, 'tasks');
   const files = [];
   try {
     if (!fs.existsSync(tasksDir)) return files;
@@ -66,9 +66,9 @@ function scanSkills(dir, scope) {
 }
 
 export function loadProjectContext({ cwd = process.cwd(), previous = null } = {}) {
-  const keplerDir = projectConfigDir(cwd);
+  const bahulamDir = projectConfigDir(cwd);
   const files = [];
-  for (const file of loadKeplerMemory({ cwd })) {
+  for (const file of loadBahulamMemory({ cwd })) {
     const label = file.path.endsWith(path.join('.bahulam', 'KEPLER.md'))
       ? 'KEPLER.md'
       : path.basename(file.path);
@@ -83,10 +83,10 @@ export function loadProjectContext({ cwd = process.cwd(), previous = null } = {}
   }
 
   for (const name of ['config.json', 'project.md', 'style.md', 'goal.md', 'plan.md', 'hitl.md']) {
-    const file = readFile(path.join(keplerDir, name), name, name.endsWith('.json') ? 4000 : 12000);
+    const file = readFile(path.join(bahulamDir, name), name, name.endsWith('.json') ? 4000 : 12000);
     if (file) files.push(file);
   }
-  files.push(...readTasks(keplerDir));
+  files.push(...readTasks(bahulamDir));
 
   const previousHashes = new Map((previous?.files || []).map(f => [f.path, f.hash]));
   const changed = files.filter(f => f.hash && previousHashes.get(f.path) && previousHashes.get(f.path) !== f.hash);
@@ -102,14 +102,14 @@ export function loadProjectContext({ cwd = process.cwd(), previous = null } = {}
 
   const skills = [
     ...scanSkills(bahulamHome(), 'global'),
-    ...scanSkills(keplerDir, 'project'),
+    ...scanSkills(bahulamDir, 'project'),
   ];
   const byName = new Map();
   for (const skill of skills) byName.set(skill.name, skill);
 
   return {
     root: cwd,
-    kepler_dir: keplerDir,
+    kepler_dir: bahulamDir,
     files,
     loaded,
     changed,

package/src/core/settings-sync.mjs

@@ -1,5 +1,5 @@
 /**
- * Settings Sync — fetch user settings from Tarang web and cache locally.
+ * Settings Sync — fetch user settings from Bahulam web and cache locally.
  *
  * Syncs: gateway_type, model preferences, configured providers.
  * Cached in ~/.bahulam/config.json alongside auth token.

package/src/core/stagnation.mjs

@@ -1,4 +1,5 @@
 export const DEFAULT_STAGNATION_THRESHOLD = 3;
+const NO_CHANGE_EDIT_TOOLS = new Set(['edit_file']);
 
 function canonicalize(value) {
     if (Array.isArray(value)) return value.map(canonicalize);
@@ -12,6 +13,26 @@ function canonicalize(value) {
     return value;
 }
 
+function editTarget(input = {}, result = {}) {
+    return String(
+        input.file_path || input.path || result.file_path || result.path || '',
+    ).trim();
+}
+
+function isNoChangeEdit(tool, result = {}) {
+    if (!NO_CHANGE_EDIT_TOOLS.has(tool)) return false;
+    if (!result || typeof result !== 'object') return false;
+    if (result._no_change || result.no_change) return true;
+    if (
+        result.success !== false
+        && result.lines_added === 0
+        && result.lines_removed === 0
+    ) {
+        return true;
+    }
+    return false;
+}
+
 export function createStagnationTracker({
     enabled = true,
     threshold = DEFAULT_STAGNATION_THRESHOLD,
@@ -21,6 +42,8 @@ export function createStagnationTracker({
         : DEFAULT_STAGNATION_THRESHOLD;
     let previousSignature = null;
     let consecutiveCount = 0;
+    let previousResultSignature = null;
+    let consecutiveResultCount = 0;
 
     return {
         record(tool, input) {
@@ -43,14 +66,51 @@ export function createStagnationTracker({
             };
         },
 
+        recordResult(tool, input, result) {
+            if (!enabled) return { detected: false, count: 0 };
+            if (!isNoChangeEdit(tool, result)) {
+                previousResultSignature = null;
+                consecutiveResultCount = 0;
+                return { detected: false, count: 0 };
+            }
+
+            const target = editTarget(input, result);
+            const signature = JSON.stringify({
+                kind: 'no_change_edit',
+                tool,
+                target,
+            });
+            if (signature === previousResultSignature) {
+                consecutiveResultCount++;
+            } else {
+                previousResultSignature = signature;
+                consecutiveResultCount = 1;
+            }
+
+            return {
+                detected: consecutiveResultCount >= effectiveThreshold,
+                count: consecutiveResultCount,
+                kind: 'no_change_edit',
+                target,
+            };
+        },
+
         reset() {
             previousSignature = null;
             consecutiveCount = 0;
+            previousResultSignature = null;
+            consecutiveResultCount = 0;
         },
     };
 }
 
-export function stagnationMessage(tool, count) {
+export function stagnationMessage(tool, count, details = {}) {
+    if (details.kind === 'no_change_edit') {
+        const target = details.target ? ` for "${details.target}"` : '';
+        return `STAGNATION WARNING: Tool "${tool}" made no file changes ${count} consecutive times${target}. ` +
+            `The duplicate edit loop was stopped. Re-read the target range, compare the current file content, ` +
+            `change the edit strategy, or finish the task.`;
+    }
     return `STAGNATION WARNING: Tool "${tool}" was called ${count} consecutive times ` +
         `with identical arguments. The duplicate call was skipped. Review the previous ` +
         `result, change the arguments, try another tool, or finish the task.`;

package/src/core/stream-client.mjs

@@ -1,8 +1,8 @@
 /**
- * TarangStreamClient — SSE consumer for Tarang backend.
+ * BahulamStreamClient — SSE consumer for Bahulam backend.
  *
  * Replaces OCC's agent-loop.mjs. Instead of calling the LLM API directly,
- * this client POSTs to the Tarang backend, parses the SSE stream, intercepts
+ * this client POSTs to the Bahulam backend, parses the SSE stream, intercepts
  * tool_request/tool_call events (executes locally, POSTs callback), and
  * yields all other events to the caller for rendering.
  *
@@ -117,10 +117,10 @@ function isOfflineLikelyError(err) {
     );
 }
 
-export class TarangStreamClient {
+export class BahulamStreamClient {
     /**
      * @param {Object} opts
-     * @param {string} opts.baseUrl - Tarang backend URL (ignored when mode='bundled')
+     * @param {string} opts.baseUrl - Bahulam backend URL (ignored when mode='bundled')
      * @param {string} opts.token - CLI auth token
      * @param {Object} opts.toolExecutor - { execute(name, args) }
      * @param {boolean} [opts.verbose=false]

package/src/core/system-prompt.mjs

@@ -10,7 +10,7 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
-import { loadKeplerMemory } from '../config/memory-loader.mjs';
+import { loadBahulamMemory } from '../config/memory-loader.mjs';
 
 /**
  * Load all CLAUDE.md files and merge them in order.
@@ -89,7 +89,7 @@ export function buildSystemPrompt({ cwd, tools, override, addDirs } = {}) {
         parts.push(f.content);
     }
 
-    for (const f of loadKeplerMemory({ cwd })) {
+    for (const f of loadBahulamMemory({ cwd })) {
         parts.push(f.content);
     }