@axplusb/kepler 0.0.1 → 1.0.1

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,135 @@
+/**
+ * System Prompt Builder — loads and merges CLAUDE.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';
+
+/**
+ * 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);
+    }
+
+    // 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;
+}