@bahulam/code 2.6.0

package/src/core/pricing.mjs

@@ -0,0 +1,336 @@
+/**
+ * Model Pricing — per-model cost calculation.
+ *
+ * Two sources of truth:
+ * 1. OpenRouter /api/v1/models endpoint (live pricing, fetched at startup)
+ * 2. Static fallback table (for non-OpenRouter providers: Anthropic, OpenAI, Google)
+ *
+ * All prices in USD per million tokens (MTok).
+ *
+ * PRD-028: Phase 1 — CLI-side pricing with live OpenRouter fetch.
+ */
+
+// ── Static Fallback Table (non-OpenRouter providers) ─────────
+
+const STATIC_PRICING = {
+    // ── Anthropic (direct API, not via OpenRouter) ──
+    'claude-opus-4':              { input: 15,    output: 75,   cache_read: 1.50,  cache_write: 18.75 },
+    'claude-sonnet-4':            { input: 3,     output: 15,   cache_read: 0.30,  cache_write: 3.75  },
+    'claude-haiku-3-5':           { input: 0.80,  output: 4,    cache_read: 0.08,  cache_write: 1.0   },
+
+    // ── OpenAI (direct API) ──
+    'gpt-4o':                     { input: 2.50,  output: 10   },
+    'gpt-4.1':                    { input: 2,     output: 8    },
+    'gpt-4.1-mini':               { input: 0.40,  output: 1.60 },
+    'gpt-4.1-nano':               { input: 0.10,  output: 0.40 },
+    'o3':                         { input: 2,     output: 8    },
+    'o3-mini':                    { input: 1.10,  output: 4.40 },
+    'o4-mini':                    { input: 1.10,  output: 4.40 },
+
+    // ── Google (direct API) ──
+    'gemini-2.5-pro':             { input: 1.25,  output: 10   },
+    'gemini-2.5-flash':           { input: 0.30,  output: 2.50 },
+    'gemini-2.0-flash':           { input: 0.10,  output: 0.40 },
+
+    // ── Bedrock (Anthropic models via AWS) ──
+    'us.anthropic.claude-sonnet-4-6-20260401-v1:0': { input: 3, output: 15, cache_read: 0.30, cache_write: 3.75 },
+    'us.anthropic.claude-haiku-4-5-20251001-v1:0':  { input: 0.80, output: 4, cache_read: 0.08, cache_write: 1.0 },
+};
+
+const DEFAULT_PRICING = { input: 3, output: 15 };
+
+// ── Live OpenRouter Pricing Cache ────────────────────────────
+
+let _openRouterPricing = null;  // Map<model_id, { input, output }>
+let _fetchPromise = null;
+
+/**
+ * Fetch live pricing from OpenRouter's /api/v1/models endpoint.
+ * Called once at startup, cached for the session.
+ * Non-blocking — returns immediately, populates cache in background.
+ */
+export async function fetchOpenRouterPricing() {
+    if (_openRouterPricing) return _openRouterPricing;
+    if (_fetchPromise) return _fetchPromise;
+
+    _fetchPromise = (async () => {
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 8000);
+
+            const res = await fetch('https://openrouter.ai/api/v1/models', {
+                signal: controller.signal,
+                headers: { 'Accept': 'application/json' },
+            });
+            clearTimeout(timeout);
+
+            if (!res.ok) return null;
+
+            const data = await res.json();
+            const models = data.data || [];
+            const pricing = new Map();
+
+            for (const m of models) {
+                const id = m.id;
+                const p = m.pricing;
+                if (!id || !p) continue;
+
+                // OpenRouter returns per-token prices as strings
+                const input = parseFloat(p.prompt || '0') * 1_000_000;   // convert to per-MTok
+                const output = parseFloat(p.completion || '0') * 1_000_000;
+
+                pricing.set(id, { input, output });
+            }
+
+            _openRouterPricing = pricing;
+            return pricing;
+        } catch {
+            // Network error, timeout, or parse error — fall back to static
+            return null;
+        } finally {
+            _fetchPromise = null;
+        }
+    })();
+
+    return _fetchPromise;
+}
+
+/**
+ * Start fetching OpenRouter pricing in the background.
+ * Call this at CLI startup — non-blocking.
+ */
+export function prefetchPricing() {
+    fetchOpenRouterPricing().catch(() => {});
+}
+
+// ── Model ID Normalization ───────────────────────────────────
+
+/**
+ * Normalize a model ID for pricing lookup.
+ * Strips version suffixes, date stamps, provider prefixes (openrouter/).
+ */
+function normalizeModelId(model) {
+    if (!model) return '';
+    let id = model.trim().toLowerCase();
+
+    // Strip 'openrouter/' prefix
+    id = id.replace(/^openrouter\//, '');
+
+    // Strip date suffixes like -20250514 or -preview-05-06
+    id = id.replace(/-\d{8}$/, '');
+    id = id.replace(/-preview[-\d]*$/, '');
+
+    return id;
+}
+
+/**
+ * Look up pricing for a model ID.
+ *
+ * Search order:
+ * 1. OpenRouter live pricing (exact match)
+ * 2. Static table (exact → normalized → provider-stripped)
+ * 3. Default fallback ($3/$15 Sonnet)
+ *
+ * @param {string} model
+ * @returns {{ input: number, output: number, cache_read?: number, cache_write?: number }}
+ */
+export function lookupPricing(model) {
+    if (!model) return DEFAULT_PRICING;
+
+    // 1. OpenRouter live cache (exact match — OpenRouter IDs are canonical)
+    if (_openRouterPricing) {
+        const orPrice = _openRouterPricing.get(model);
+        if (orPrice) return orPrice;
+
+        // Try normalized
+        const normalized = normalizeModelId(model);
+        const orNorm = _openRouterPricing.get(normalized);
+        if (orNorm) return orNorm;
+    }
+
+    // 2. Static table — exact match
+    if (STATIC_PRICING[model]) return STATIC_PRICING[model];
+
+    // Normalized match
+    const normalized = normalizeModelId(model);
+    if (STATIC_PRICING[normalized]) return STATIC_PRICING[normalized];
+
+    // Try without provider prefix (e.g. 'google/gemini-2.5-pro' → 'gemini-2.5-pro')
+    const withoutProvider = normalized.replace(/^[^/]+\//, '');
+    if (STATIC_PRICING[withoutProvider]) return STATIC_PRICING[withoutProvider];
+
+    // Try with common provider prefixes
+    for (const prefix of ['deepseek/', 'xiaomi/', 'google/', 'meta/', 'qwen/', 'moonshotai/']) {
+        if (STATIC_PRICING[prefix + withoutProvider]) return STATIC_PRICING[prefix + withoutProvider];
+    }
+
+    // 3. OpenRouter fuzzy match (without provider prefix)
+    if (_openRouterPricing) {
+        for (const [id, price] of _openRouterPricing) {
+            if (id.endsWith('/' + withoutProvider)) return price;
+        }
+    }
+
+    return DEFAULT_PRICING;
+}
+
+// ── Cost Calculation ─────────────────────────────────────────
+
+/**
+ * Calculate cost from a usage object.
+ *
+ * Supports two formats:
+ * 1. New format (with per-model breakdown):
+ *    { models: [{ model, input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens }] }
+ *
+ * 2. Legacy format (flat tokens, no model):
+ *    { input_tokens, output_tokens }
+ *
+ * @param {Object} usage - Usage object from backend complete event
+ * @returns {{ total: number, breakdown: Array, accurate: boolean }}
+ */
+export function calculateCost(usage) {
+    if (!usage) return { total: 0, breakdown: [], accurate: false };
+
+    // Best case: backend computed cost from live OpenRouter pricing
+    if (typeof usage.total_cost === 'number' && usage.models && usage.models.length > 0) {
+        const breakdown = usage.models.map(m => ({
+            model: m.model,
+            role: m.role || 'unknown',
+            input_tokens: m.input_tokens || 0,
+            output_tokens: m.output_tokens || 0,
+            cache_read_tokens: m.cache_read_tokens || 0,
+            cache_creation_tokens: m.cache_creation_tokens || 0,
+            cost: m.cost || 0,
+            free: (m.cost || 0) === 0 && (m.input_tokens || 0) > 0,
+            pricingSource: 'backend',
+        }));
+
+        return {
+            total: usage.total_cost,
+            breakdown,
+            accurate: true,
+        };
+    }
+
+    // Fallback: per-model breakdown without backend cost — CLI computes
+    if (usage.models && usage.models.length > 0) {
+        const breakdown = usage.models.map(m => {
+            const pricing = lookupPricing(m.model);
+            const inputCost = (m.input_tokens || 0) * pricing.input / 1_000_000;
+            const outputCost = (m.output_tokens || 0) * pricing.output / 1_000_000;
+            const cacheReadCost = (m.cache_read_tokens || 0) * (pricing.cache_read || pricing.input) / 1_000_000;
+            const cacheWriteCost = (m.cache_creation_tokens || 0) * (pricing.cache_write || pricing.input) / 1_000_000;
+            const cost = inputCost + outputCost + cacheReadCost + cacheWriteCost;
+
+            const usedLivePricing = _openRouterPricing?.has(m.model) || false;
+            const usedStaticPricing = STATIC_PRICING[m.model] || STATIC_PRICING[normalizeModelId(m.model)];
+
+            return {
+                model: m.model,
+                role: m.role || 'unknown',
+                input_tokens: m.input_tokens || 0,
+                output_tokens: m.output_tokens || 0,
+                cache_read_tokens: m.cache_read_tokens || 0,
+                cache_creation_tokens: m.cache_creation_tokens || 0,
+                cost,
+                free: pricing.input === 0 && pricing.output === 0,
+                pricingSource: usedLivePricing ? 'openrouter' : usedStaticPricing ? 'static' : 'default',
+            };
+        });
+
+        const allAccurate = breakdown.every(b => b.pricingSource !== 'default');
+
+        return {
+            total: breakdown.reduce((sum, b) => sum + b.cost, 0),
+            breakdown,
+            accurate: allAccurate,
+        };
+    }
+
+    // Legacy format: flat tokens, unknown model — use default pricing
+    const inputTokens = usage.total_input_tokens || usage.input_tokens || 0;
+    const outputTokens = usage.total_output_tokens || usage.output_tokens || 0;
+    const total = (inputTokens * DEFAULT_PRICING.input + outputTokens * DEFAULT_PRICING.output) / 1_000_000;
+
+    return {
+        total,
+        breakdown: [{
+            model: 'unknown',
+            role: 'unknown',
+            input_tokens: inputTokens,
+            output_tokens: outputTokens,
+            cost: total,
+            free: false,
+            pricingSource: 'default',
+        }],
+        accurate: false,
+    };
+}
+
+// ── Formatting ───────────────────────────────────────────────
+
+/**
+ * Format a cost value as a dollar string (diagnostic/telemetry only).
+ * @param {number} cost
+ * @returns {string}
+ */
+export function formatCostValue(cost) {
+    if (cost === 0) return '$0.00';
+    if (cost < 0.01) return `$${cost.toFixed(4)}`;
+    return `$${cost.toFixed(2)}`;
+}
+
+/**
+ * Convert provider cost to Kepler credits.
+ * 100 credits = $1 of retail model usage, 2x multiplier.
+ * @param {number} costUsd
+ * @returns {number}
+ */
+export function costToCredits(costUsd) {
+    if (costUsd <= 0) return 0;
+    return Math.max(1, Math.ceil(costUsd * 2.0 * 100));
+}
+
+/**
+ * Format credits for display (e.g. "5 cr", "1.2k cr").
+ * @param {number} credits
+ * @returns {string}
+ */
+export function formatCredits(credits) {
+    if (credits === 0) return '0 cr';
+    if (credits >= 1000) return `${(credits / 1000).toFixed(1)}k cr`;
+    return `${credits} cr`;
+}
+
+/**
+ * Format a token count for display (e.g. 42100 → '42.1k').
+ * @param {number} tokens
+ * @returns {string}
+ */
+export function formatTokens(tokens) {
+    if (tokens === 0) return '0';
+    if (tokens < 1000) return String(tokens);
+    return `${(tokens / 1000).toFixed(1)}k`;
+}
+
+/**
+ * Check if a model is free-tier.
+ * @param {string} model
+ * @returns {boolean}
+ */
+export function isFreeModel(model) {
+    const pricing = lookupPricing(model);
+    return pricing.input === 0 && pricing.output === 0;
+}
+
+/**
+ * Get pricing status (for /status display).
+ * @returns {{ source: string, modelCount: number }}
+ */
+export function getPricingStatus() {
+    if (_openRouterPricing) {
+        return { source: 'openrouter-live', modelCount: _openRouterPricing.size };
+    }
+    return { source: 'static-fallback', modelCount: Object.keys(STATIC_PRICING).length };
+}

package/src/core/project-artifacts.mjs

@@ -0,0 +1,39 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { projectConfigDir } from './paths.mjs';
+
+/**
+ * Persist generated session artifacts only beneath roots registered by the CLI.
+ */
+export function persistProjectArtifacts(data, resources, log = () => {}) {
+    const projectIds = new Set(
+        Array.isArray(data?.project_ids) ? data.project_ids.filter(Boolean) : []
+    );
+    const registered = Array.isArray(resources) ? resources : [];
+    const targets = projectIds.size > 0
+        ? registered.filter(resource => projectIds.has(resource.project_id))
+        : registered.length === 1 ? registered : [];
+    const artifacts = [
+        ['goal', 'goal.md'],
+        ['plan', 'plan.md'],
+    ].filter(([field]) => typeof data?.[field] === 'string' && data[field].trim());
+    const written = [];
+
+    for (const resource of targets) {
+        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);
+                fs.writeFileSync(artifactPath, data[field], 'utf-8');
+                resource[field] = data[field];
+                written.push(artifactPath);
+                log(`${field} saved -> ${artifactPath}`);
+            } catch {
+                // Persistence is helpful but must not stop the agent.
+            }
+        }
+    }
+    return written;
+}

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

@@ -0,0 +1,139 @@
+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 { bahulamHome, projectConfigDir } from './paths.mjs';
+
+function sha(content) {
+  return crypto.createHash('sha256').update(content || '').digest('hex').slice(0, 12);
+}
+
+function readFile(filePath, label, maxChars = 12000) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return {
+      label,
+      path: filePath,
+      hash: sha(content),
+      bytes: Buffer.byteLength(content),
+      content: content.length > maxChars
+        ? content.slice(0, maxChars) + '\n\n[...truncated...]'
+        : content,
+      truncated: content.length > maxChars,
+    };
+  } catch (err) {
+    return { label, path: filePath, error: err.message, content: '' };
+  }
+}
+
+function readTasks(keplerDir) {
+  const tasksDir = path.join(keplerDir, 'tasks');
+  const files = [];
+  try {
+    if (!fs.existsSync(tasksDir)) return files;
+    for (const name of fs.readdirSync(tasksDir).sort()) {
+      if (!name.endsWith('.md')) continue;
+      const file = readFile(path.join(tasksDir, name), `tasks/${name}`, 6000);
+      if (file) files.push(file);
+    }
+  } catch { /* best effort */ }
+  return files;
+}
+
+function scanSkills(dir, scope) {
+  const skillsDir = path.join(dir, 'skills');
+  const out = [];
+  try {
+    if (!fs.existsSync(skillsDir)) return out;
+    for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
+      let filePath = null;
+      let name = entry.name;
+      if (entry.isDirectory()) filePath = path.join(skillsDir, entry.name, 'SKILL.md');
+      else if (entry.isFile() && entry.name.endsWith('.md')) {
+        filePath = path.join(skillsDir, entry.name);
+        name = entry.name.replace(/\.md$/, '');
+      }
+      if (!filePath || !fs.existsSync(filePath)) continue;
+      const raw = fs.readFileSync(filePath, 'utf-8');
+      const desc = raw.match(/^description:\s*(.+)$/mi)?.[1]?.trim()
+        || raw.match(/^#\s+.+\n+([^\n]+)/)?.[1]?.trim()
+        || '';
+      out.push({ name, description: desc, scope, source_id: `${scope}:${name}`, path: filePath });
+    }
+  } catch { /* best effort */ }
+  return out;
+}
+
+export function loadProjectContext({ cwd = process.cwd(), previous = null } = {}) {
+  const keplerDir = projectConfigDir(cwd);
+  const files = [];
+  for (const file of loadKeplerMemory({ cwd })) {
+    const label = file.path.endsWith(path.join('.bahulam', 'KEPLER.md'))
+      ? 'KEPLER.md'
+      : path.basename(file.path);
+    files.push({
+      label,
+      source: file.source,
+      path: file.path,
+      hash: sha(file.content),
+      bytes: Buffer.byteLength(file.content),
+      content: file.content,
+    });
+  }
+
+  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);
+    if (file) files.push(file);
+  }
+  files.push(...readTasks(keplerDir));
+
+  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);
+  const loaded = files.filter(f => !f.error).map(f => ({
+    label: f.label,
+    path: f.path,
+    hash: f.hash,
+    bytes: f.bytes,
+    source: f.source || 'project',
+    included: true,
+    changed: changed.some(c => c.path === f.path),
+  }));
+
+  const skills = [
+    ...scanSkills(bahulamHome(), 'global'),
+    ...scanSkills(keplerDir, 'project'),
+  ];
+  const byName = new Map();
+  for (const skill of skills) byName.set(skill.name, skill);
+
+  return {
+    root: cwd,
+    kepler_dir: keplerDir,
+    files,
+    loaded,
+    changed,
+    available_skills: [...byName.values()],
+    task_state: files
+      .filter(f => f.label.startsWith('tasks/'))
+      .map(f => ({ name: f.label.replace('tasks/', ''), hash: f.hash, content: f.content })),
+    loaded_at: new Date().toISOString(),
+  };
+}
+
+export function contextToPromptBlock(context) {
+  const parts = [];
+  if (context?.root) {
+    parts.push([
+      '--- task workflow ---',
+      'Keep .bahulam/tasks/active.md current for the work in progress.',
+      'Use .bahulam/tasks/backlog.md for deferred work, .bahulam/tasks/blocked.md for items waiting on input, and .bahulam/tasks/done.md for completed work.',
+      'When the task state changes materially, update the appropriate task markdown file before the turn finishes.',
+    ].join('\n'));
+  }
+  for (const file of context?.files || []) {
+    if (!file.content || file.label === 'config.json') continue;
+    parts.push(`--- ${file.label} (${file.hash}) ---\n${file.content}`);
+  }
+  return parts.join('\n\n');
+}