@bahulam/code 2.6.0

package/src/core/streaming.mjs

@@ -0,0 +1,182 @@
+/**
+ * Streaming Handler — processes Anthropic SSE events from the Messages API.
+ *
+ * Handles ALL SSE event types:
+ * - message_start, message_delta, message_stop
+ * - content_block_start, content_block_delta, content_block_stop
+ * - ping
+ * - error
+ *
+ * Parses:
+ * - thinking blocks (type: "thinking")
+ * - tool_use input streaming (type: "input_json_delta")
+ * - Usage tracking from message_delta.usage
+ */
+
+/**
+ * Parse an SSE stream from an Anthropic streaming response.
+ * @param {Response} response - fetch Response with streaming body
+ * @yields {object} Parsed SSE event data
+ */
+export async function* streamResponse(response) {
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+
+            buffer += decoder.decode(value, { stream: true });
+
+            // SSE events are separated by double newlines
+            while (buffer.includes('\n\n')) {
+                const idx = buffer.indexOf('\n\n');
+                const chunk = buffer.slice(0, idx);
+                buffer = buffer.slice(idx + 2);
+
+                const event = parseSSEChunk(chunk);
+                if (event) yield event;
+            }
+        }
+
+        // Handle remaining buffer
+        if (buffer.trim()) {
+            const event = parseSSEChunk(buffer.trim());
+            if (event) yield event;
+        }
+    } finally {
+        reader.releaseLock();
+    }
+}
+
+/**
+ * Parse a single SSE chunk into an event object.
+ * @param {string} chunk - raw SSE text (may contain event: and data: lines)
+ * @returns {object|null} Parsed event or null
+ */
+function parseSSEChunk(chunk) {
+    let eventType = null;
+    let dataLines = [];
+
+    for (const line of chunk.split('\n')) {
+        if (line.startsWith('event: ')) {
+            eventType = line.slice(7).trim();
+        } else if (line.startsWith('data: ')) {
+            dataLines.push(line.slice(6));
+        } else if (line.startsWith(':')) {
+            // SSE comment, ignore
+            continue;
+        }
+    }
+
+    // Handle ping events (no data)
+    if (eventType === 'ping') {
+        return { type: 'ping' };
+    }
+
+    if (dataLines.length === 0) return null;
+
+    const raw = dataLines.join('\n');
+    if (raw === '[DONE]') return { type: 'done' };
+
+    try {
+        const data = JSON.parse(raw);
+        return { type: eventType || data.type || 'unknown', ...data };
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Accumulate streaming events into a complete message response.
+ * Collects content blocks, thinking blocks, and usage stats.
+ *
+ * @param {AsyncIterable} events - stream of SSE events
+ * @returns {object} Complete message in the same shape as non-streaming API
+ */
+export async function accumulateStream(events) {
+    const message = {
+        id: null,
+        role: 'assistant',
+        content: [],
+        model: null,
+        stop_reason: null,
+        usage: { input_tokens: 0, output_tokens: 0, cache_creation_input_tokens: 0, cache_read_input_tokens: 0 },
+    };
+
+    let currentBlock = null;
+    let blockIndex = -1;
+
+    for await (const event of events) {
+        switch (event.type) {
+            case 'message_start':
+                if (event.message) {
+                    message.id = event.message.id;
+                    message.model = event.message.model;
+                    if (event.message.usage) {
+                        message.usage.input_tokens = event.message.usage.input_tokens || 0;
+                        message.usage.cache_creation_input_tokens = event.message.usage.cache_creation_input_tokens || 0;
+                        message.usage.cache_read_input_tokens = event.message.usage.cache_read_input_tokens || 0;
+                    }
+                }
+                break;
+
+            case 'content_block_start':
+                blockIndex = event.index ?? message.content.length;
+                currentBlock = { ...event.content_block };
+                if (currentBlock.type === 'text') currentBlock.text = '';
+                if (currentBlock.type === 'thinking') currentBlock.thinking = '';
+                if (currentBlock.type === 'tool_use') {
+                    currentBlock.input = '';
+                }
+                message.content[blockIndex] = currentBlock;
+                break;
+
+            case 'content_block_delta':
+                if (!currentBlock) break;
+                if (event.delta?.type === 'text_delta') {
+                    currentBlock.text += event.delta.text;
+                } else if (event.delta?.type === 'thinking_delta') {
+                    currentBlock.thinking += event.delta.thinking;
+                } else if (event.delta?.type === 'input_json_delta') {
+                    currentBlock.input += event.delta.partial_json;
+                }
+                break;
+
+            case 'content_block_stop':
+                // Parse tool_use input from accumulated JSON string
+                if (currentBlock?.type === 'tool_use' && typeof currentBlock.input === 'string') {
+                    try {
+                        currentBlock.input = JSON.parse(currentBlock.input || '{}');
+                    } catch {
+                        currentBlock.input = {};
+                    }
+                }
+                currentBlock = null;
+                break;
+
+            case 'message_delta':
+                if (event.delta?.stop_reason) {
+                    message.stop_reason = event.delta.stop_reason;
+                }
+                if (event.usage) {
+                    message.usage.output_tokens = event.usage.output_tokens || 0;
+                }
+                break;
+
+            case 'message_stop':
+                break;
+
+            case 'ping':
+                // Keepalive, ignore
+                break;
+
+            case 'error':
+                throw new Error(`Stream error: ${event.error?.message || JSON.stringify(event)}`);
+        }
+    }
+
+    return message;
+}

package/src/core/system-prompt.mjs

@@ -0,0 +1,140 @@
+/**
+ * System Prompt Builder — loads and merges CLAUDE.md and KEPLER.md files.
+ *
+ * Features:
+ * - Loads CLAUDE.md from: ~/.claude/CLAUDE.md, project root, parent dirs
+ * - Merges in order (global -> project -> local)
+ * - Splits at cache boundary (static prefix cached, dynamic suffix not)
+ * - Includes tool schemas in the system prompt
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { loadKeplerMemory } from '../config/memory-loader.mjs';
+
+/**
+ * Load all CLAUDE.md files and merge them in order.
+ * @param {string} [cwd] - current working directory
+ * @returns {string[]} Array of CLAUDE.md contents in merge order
+ */
+export function loadClaudeMdFiles(cwd = process.cwd()) {
+    const files = [];
+
+    // 1. Global: ~/.claude/CLAUDE.md
+    const globalPath = path.join(os.homedir(), '.claude', 'CLAUDE.md');
+    if (fs.existsSync(globalPath)) {
+        try {
+            files.push({ source: 'global', content: fs.readFileSync(globalPath, 'utf-8') });
+        } catch { /* skip */ }
+    }
+
+    // 2. Walk from cwd up to root, collecting CLAUDE.md files
+    const projectFiles = [];
+    let dir = path.resolve(cwd);
+    const root = path.parse(dir).root;
+    while (dir !== root) {
+        const candidates = [
+            path.join(dir, 'CLAUDE.md'),
+            path.join(dir, '.claude', 'CLAUDE.md'),
+        ];
+        for (const f of candidates) {
+            if (fs.existsSync(f)) {
+                try {
+                    projectFiles.push({ source: dir, content: fs.readFileSync(f, 'utf-8'), path: f });
+                } catch { /* skip */ }
+            }
+        }
+        dir = path.dirname(dir);
+    }
+
+    // Reverse so parent dirs come first (global -> project -> local)
+    projectFiles.reverse();
+    files.push(...projectFiles);
+
+    return files;
+}
+
+/**
+ * Build the full system prompt from CLAUDE.md files and tool schemas.
+ * @param {object} options
+ * @param {string} [options.cwd] - current working directory
+ * @param {Array} [options.tools] - tool definitions for schema inclusion
+ * @param {string} [options.override] - override system prompt entirely
+ * @param {string[]} [options.addDirs] - additional directories to search for CLAUDE.md
+ * @returns {{ staticPrefix: string, dynamicSuffix: string, full: string }}
+ */
+export function buildSystemPrompt({ cwd, tools, override, addDirs } = {}) {
+    if (override) {
+        return { staticPrefix: override, dynamicSuffix: '', full: override };
+    }
+
+    const parts = ['You are an AI coding assistant.'];
+
+    // Load CLAUDE.md files
+    const mdFiles = loadClaudeMdFiles(cwd);
+
+    // Add additional directories
+    if (addDirs) {
+        for (const dir of addDirs) {
+            const p = path.join(dir, 'CLAUDE.md');
+            if (fs.existsSync(p)) {
+                try {
+                    mdFiles.push({ source: dir, content: fs.readFileSync(p, 'utf-8') });
+                } catch { /* skip */ }
+            }
+        }
+    }
+
+    for (const f of mdFiles) {
+        parts.push(f.content);
+    }
+
+    for (const f of loadKeplerMemory({ cwd })) {
+        parts.push(f.content);
+    }
+
+    // The static prefix is the base prompt + CLAUDE.md content (cacheable)
+    const staticPrefix = parts.join('\n\n');
+
+    // Dynamic suffix includes tool schemas (changes per-request)
+    let dynamicSuffix = '';
+    if (tools && tools.length > 0) {
+        const toolSummary = tools.map(t =>
+            `- ${t.name}: ${(t.description || '').slice(0, 100)}`
+        ).join('\n');
+        dynamicSuffix = `\n\nAvailable tools:\n${toolSummary}`;
+    }
+
+    return {
+        staticPrefix,
+        dynamicSuffix,
+        full: staticPrefix + dynamicSuffix,
+    };
+}
+
+/**
+ * Convert system prompt to Anthropic cache-control format.
+ * @param {string} staticPrefix
+ * @param {string} dynamicSuffix
+ * @returns {Array} system blocks with cache_control
+ */
+export function toCacheBlocks(staticPrefix, dynamicSuffix) {
+    const blocks = [];
+
+    if (staticPrefix) {
+        blocks.push({
+            type: 'text',
+            text: staticPrefix,
+            cache_control: { type: 'ephemeral' },
+        });
+    }
+
+    if (dynamicSuffix) {
+        blocks.push({
+            type: 'text',
+            text: dynamicSuffix,
+        });
+    }
+
+    return blocks;
+}

package/src/core/tasks.mjs

@@ -0,0 +1,196 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+export const TASK_FILES = Object.freeze({
+  active: 'active.md',
+  backlog: 'backlog.md',
+  blocked: 'blocked.md',
+  done: 'done.md',
+});
+
+const DEFAULT_CONTENT = Object.freeze({
+  'README.md': '# Bahulam Tasks\n\nChecklist files are read every turn.\n',
+  'active.md': '# Active\n\n',
+  'backlog.md': '# Backlog\n\n',
+  'blocked.md': '# Blocked\n\n',
+  'done.md': '# Done\n\n',
+});
+
+export function ensureTaskFiles({ cwd = process.cwd() } = {}) {
+  const dir = path.join(cwd, '.bahulam', 'tasks');
+  fs.mkdirSync(dir, { recursive: true });
+  const written = [];
+  for (const [name, content] of Object.entries(DEFAULT_CONTENT)) {
+    const filePath = path.join(dir, name);
+    if (fs.existsSync(filePath)) continue;
+    fs.writeFileSync(filePath, content);
+    written.push(filePath);
+  }
+  return { dir, written };
+}
+
+export function loadTaskBoard({ cwd = process.cwd(), create = false } = {}) {
+  const dir = path.join(cwd, '.bahulam', 'tasks');
+  if (create) ensureTaskFiles({ cwd });
+  const lists = {};
+  for (const [list, fileName] of Object.entries(TASK_FILES)) {
+    const filePath = path.join(dir, fileName);
+    const content = readText(filePath);
+    lists[list] = {
+      list,
+      fileName,
+      path: filePath,
+      exists: fs.existsSync(filePath),
+      content,
+      tasks: parseTaskMarkdown(content, list),
+    };
+  }
+
+  const planPath = path.join(cwd, '.bahulam', 'plan.md');
+  const goalPath = path.join(cwd, '.bahulam', 'goal.md');
+  return {
+    dir,
+    lists,
+    plan: { path: planPath, exists: fs.existsSync(planPath), content: readText(planPath) },
+    goal: { path: goalPath, exists: fs.existsSync(goalPath), content: readText(goalPath) },
+  };
+}
+
+export function appendTask({ cwd = process.cwd(), list = 'backlog', text }) {
+  const normalized = normalizeList(list);
+  const taskText = String(text || '').trim();
+  if (!taskText) throw new Error('Task text is required');
+  const { dir } = ensureTaskFiles({ cwd });
+  const filePath = path.join(dir, TASK_FILES[normalized]);
+  const prefix = normalized === 'done' ? '- [x]' : '- [ ]';
+  fs.appendFileSync(filePath, `${prefix} ${taskText}\n`);
+  return { list: normalized, path: filePath, text: taskText };
+}
+
+export function updateTask({ cwd = process.cwd(), list = 'active', index, text, checked } = {}) {
+  const normalized = normalizeList(list);
+  const taskIndex = normalizeTaskIndex(index);
+  ensureTaskFiles({ cwd });
+  const filePath = taskFilePath(cwd, normalized);
+  const content = readText(filePath);
+  const tasks = parseTaskMarkdown(content, normalized);
+  const task = tasks[taskIndex - 1];
+  if (!task) throw new Error(`No task ${taskIndex} in ${normalized}`);
+
+  const lines = content.split(/\r?\n/);
+  const nextText = String(text ?? task.text).trim();
+  if (!nextText) throw new Error('Task text is required');
+  const nextChecked = checked === undefined ? task.checked : Boolean(checked);
+  lines[task.line - 1] = taskLine(nextText, normalized, nextChecked);
+  fs.writeFileSync(filePath, lines.join('\n'));
+  return { list: normalized, path: filePath, index: taskIndex, previous: task, text: nextText, checked: nextChecked };
+}
+
+export function removeTask({ cwd = process.cwd(), list = 'active', index } = {}) {
+  const normalized = normalizeList(list);
+  const taskIndex = normalizeTaskIndex(index);
+  ensureTaskFiles({ cwd });
+  const filePath = taskFilePath(cwd, normalized);
+  const content = readText(filePath);
+  const tasks = parseTaskMarkdown(content, normalized);
+  const task = tasks[taskIndex - 1];
+  if (!task) throw new Error(`No task ${taskIndex} in ${normalized}`);
+
+  const lines = content.split(/\r?\n/);
+  lines.splice(task.line - 1, 1);
+  fs.writeFileSync(filePath, lines.join('\n'));
+  return { list: normalized, path: filePath, index: taskIndex, task };
+}
+
+export function moveTask({ cwd = process.cwd(), from = 'active', index, to = 'done', text } = {}) {
+  const source = normalizeList(from);
+  const target = normalizeList(to);
+  const removed = removeTask({ cwd, list: source, index });
+  const taskText = String(text ?? removed.task.text).trim();
+  const appended = appendTask({ cwd, list: target, text: taskText });
+  return {
+    from: source,
+    to: target,
+    index: removed.index,
+    text: taskText,
+    sourcePath: removed.path,
+    targetPath: appended.path,
+  };
+}
+
+export function taskCounts(board) {
+  const lists = board?.lists || {};
+  return Object.fromEntries(
+    Object.entries(TASK_FILES).map(([list]) => [list, lists[list]?.tasks?.length || 0]),
+  );
+}
+
+export function normalizeList(value) {
+  const key = String(value || '').toLowerCase();
+  if (key === 'todo' || key === 'pending') return 'backlog';
+  if (key === 'current' || key === 'doing') return 'active';
+  if (key === 'complete' || key === 'completed') return 'done';
+  if (key in TASK_FILES) return key;
+  throw new Error(`Unknown task list: ${value}`);
+}
+
+function normalizeTaskIndex(value) {
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 1) throw new Error('Task index must be a positive number');
+  return n;
+}
+
+function taskFilePath(cwd, list) {
+  return path.join(cwd, '.bahulam', 'tasks', TASK_FILES[list]);
+}
+
+function taskLine(text, list, checked = false) {
+  const mark = checked || list === 'done' ? 'x' : ' ';
+  return `- [${mark}] ${text}`;
+}
+
+function readText(filePath) {
+  try {
+    return fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : '';
+  } catch {
+    return '';
+  }
+}
+
+export function parseTaskMarkdown(content, list = 'backlog') {
+  const tasks = [];
+  let section = '';
+  const lines = String(content || '').split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const heading = line.match(/^#{1,6}\s+(.+?)\s*$/);
+    if (heading) {
+      section = heading[1].trim();
+      continue;
+    }
+
+    const checkbox = line.match(/^\s*[-*]\s+\[([ xX!-])\]\s+(.+?)\s*$/);
+    if (checkbox) {
+      tasks.push({
+        list,
+        line: i + 1,
+        section,
+        checked: checkbox[1].toLowerCase() === 'x',
+        text: checkbox[2].trim(),
+      });
+      continue;
+    }
+
+    const bullet = line.match(/^\s*[-*]\s+(.+?)\s*$/);
+    if (bullet && !bullet[1].startsWith('`')) {
+      tasks.push({
+        list,
+        line: i + 1,
+        section,
+        checked: list === 'done',
+        text: bullet[1].trim(),
+      });
+    }
+  }
+  return tasks;
+}