@koi-language/koi 1.0.0

package/src/runtime/cli-logger.js

@@ -0,0 +1,205 @@
+/**
+ * CLI Logger - Single-line progress updates like Claude Code CLI
+ *
+ * Usage:
+ *   cliLogger.progress('Processing...') - Updates same line
+ *   cliLogger.success('Done!') - New line with result
+ *   cliLogger.error('Failed!') - New line with error
+ *   cliLogger.clear() - Clear current line
+ */
+
+class CLILogger {
+  constructor() {
+    this.currentLine = '';
+    this.isProgress = false;
+    this.animationInterval = null;
+    this.animationDots = 0;
+    this.isAnimating = false; // Track if we're in animation mode
+    this.indentStack = []; // Stack of messages showing delegation hierarchy
+    this.indentLevel = 0;
+
+    // Intercept console methods to auto-clear progress
+    this.setupConsoleIntercept();
+  }
+
+  setupConsoleIntercept() {
+    const originalLog = console.log;
+    const originalError = console.error;
+    const originalWarn = console.warn;
+    const originalInfo = console.info;
+    const self = this;
+
+    console.log = function(...args) {
+      self.clearProgress();
+      originalLog.apply(console, args);
+    };
+
+    console.error = function(...args) {
+      self.clearProgress();
+      originalError.apply(console, args);
+    };
+
+    console.warn = function(...args) {
+      self.clearProgress();
+      originalWarn.apply(console, args);
+    };
+
+    console.info = function(...args) {
+      self.clearProgress();
+      originalInfo.apply(console, args);
+    };
+  }
+
+  /**
+   * Push a message to the delegation stack (indented)
+   */
+  pushIndent(message) {
+    this.indentLevel++;
+    const indent = '  '.repeat(this.indentLevel);
+    this.indentStack.push({ message, indent, level: this.indentLevel });
+    this.progress(`${indent}→ ${message}`);
+  }
+
+  /**
+   * Pop the last delegation from stack and restore parent context
+   */
+  popIndent() {
+    if (this.indentStack.length > 0) {
+      this.indentStack.pop();
+      this.indentLevel = Math.max(0, this.indentLevel - 1);
+
+      // Clear and restore parent context
+      this.clear();
+
+      // Re-render parent if exists
+      if (this.indentStack.length > 0) {
+        const parent = this.indentStack[this.indentStack.length - 1];
+        this.progress(`${parent.indent}→ ${parent.message}`);
+      }
+    } else {
+      this.indentLevel = 0;
+    }
+  }
+
+  /**
+   * Clear all indentation stack
+   */
+  clearStack() {
+    this.indentStack = [];
+    this.indentLevel = 0;
+    this.clear();
+  }
+
+  /**
+   * Get current indent string
+   */
+  getIndent() {
+    return '  '.repeat(this.indentLevel);
+  }
+
+  /**
+   * Show planning state with animated spinning stick
+   */
+  planning(prefix) {
+    // Stop any existing animation
+    this.stopAnimation();
+
+    const baseMessage = prefix || 'Thinking';
+    this.animationDots = 0;
+    this.isAnimating = true;
+    const spinnerChars = ['|', '/', '-', '\\'];
+
+    // Initial render
+    this.progress(`${baseMessage} ${spinnerChars[0]}`);
+
+    // Start animation
+    this.animationInterval = setInterval(() => {
+      this.animationDots = (this.animationDots + 1) % spinnerChars.length;
+      const spinner = spinnerChars[this.animationDots];
+      this.progress(`${baseMessage} ${spinner}`);
+    }, 150);
+  }
+
+  /**
+   * Stop animation if running
+   */
+  stopAnimation() {
+    if (this.animationInterval) {
+      clearInterval(this.animationInterval);
+      this.animationInterval = null;
+      this.animationDots = 0;
+      this.isAnimating = false;
+    }
+  }
+
+  /**
+   * Update the same line with progress (no newline)
+   */
+  progress(message) {
+    // Stop animation if it's running and we're not in animation mode
+    if (this.animationInterval && !this.isAnimating && !message.includes('...')) {
+      this.stopAnimation();
+    }
+
+    // Clear previous line
+    if (this.isProgress) {
+      process.stdout.write('\r\x1b[K');
+    }
+
+    // Write new message
+    process.stdout.write(message);
+    this.currentLine = message;
+    this.isProgress = true;
+  }
+
+  /**
+   * Complete progress and print result on new line
+   */
+  success(message) {
+    this.clearProgress();
+    console.log(message);
+  }
+
+  /**
+   * Print error on new line
+   */
+  error(message) {
+    this.clearProgress();
+    console.error(message);
+  }
+
+  /**
+   * Print info on new line
+   */
+  info(message) {
+    this.clearProgress();
+    console.log(message);
+  }
+
+  /**
+   * Clear current progress line
+   */
+  clearProgress() {
+    this.stopAnimation();
+    if (this.isProgress) {
+      process.stdout.write('\r\x1b[K');
+      this.isProgress = false;
+      this.currentLine = '';
+    }
+  }
+
+  /**
+   * Just clear, no new line
+   */
+  clear() {
+    this.stopAnimation();
+    if (this.isProgress) {
+      process.stdout.write('\r\x1b[K');
+      this.isProgress = false;
+      this.currentLine = '';
+    }
+  }
+}
+
+// Singleton instance
+export const cliLogger = new CLILogger();

package/src/runtime/incremental-json-parser.js

@@ -0,0 +1,201 @@
+/**
+ * Incremental JSON Parser for Streaming LLM Responses
+ *
+ * Parses JSON stream incrementally and yields complete action objects
+ * as soon as they're fully received, without waiting for the entire response.
+ */
+
+export class IncrementalJSONParser {
+  constructor() {
+    this.buffer = '';
+    this.actionsStartIndex = -1; // Position where "actions":[ was found
+    this.lastParsedIndex = 0; // Last position we successfully parsed up to
+    this.parsedActions = 0; // Count of actions we've parsed
+  }
+
+  /**
+   * Feed more content from the stream
+   * Returns array of complete actions found in this chunk
+   */
+  feed(chunk) {
+    const actions = [];
+    const oldBufferLength = this.buffer.length;
+    this.buffer += chunk;
+
+    // First, find where the actions array starts (if we haven't found it yet)
+    if (this.actionsStartIndex === -1) {
+      // Look for "actions" : [ with flexible whitespace
+      const match = this.buffer.match(/"actions"\s*:\s*\[/);
+      if (match) {
+        const actionsIndex = match.index;
+        this.actionsStartIndex = actionsIndex + match[0].length; // Position right after "actions": [
+        this.lastParsedIndex = this.actionsStartIndex;
+
+        if (process.env.KOI_DEBUG_LLM) {
+          console.error(`[IncrementalParser] 📍 Found "actions" array at position ${actionsIndex}, starting to parse from ${this.actionsStartIndex}`);
+        }
+      } else {
+        // Haven't found actions array yet, wait for more data
+        if (process.env.KOI_DEBUG_LLM && this.buffer.length > 50) {
+          // Show first 100 chars of buffer to debug what LLM is generating
+          const preview = this.buffer.substring(0, 100).replace(/\n/g, '\\n');
+          console.error(`[IncrementalParser] ⏳ Waiting for "actions" array (buffer: ${this.buffer.length} chars, preview: "${preview}...")`);
+        }
+        return actions;
+      }
+    }
+
+    // Try to parse actions from the buffer
+    // We'll try to extract complete JSON objects from the actions array
+    let currentPos = this.lastParsedIndex;
+    let depth = 0;
+    let inString = false;
+    let escapeNext = false;
+    let objectStart = -1;
+
+    for (let i = currentPos; i < this.buffer.length; i++) {
+      const char = this.buffer[i];
+
+      // Handle string escaping
+      if (escapeNext) {
+        escapeNext = false;
+        continue;
+      }
+
+      if (char === '\\' && inString) {
+        escapeNext = true;
+        continue;
+      }
+
+      // Track if we're inside a string
+      if (char === '"') {
+        inString = !inString;
+        continue;
+      }
+
+      // Skip processing inside strings
+      if (inString) {
+        continue;
+      }
+
+      // Track object depth
+      if (char === '{') {
+        if (depth === 0) {
+          objectStart = i; // Start of new action object
+        }
+        depth++;
+      } else if (char === '}') {
+        depth--;
+        if (depth === 0 && objectStart !== -1) {
+          // Complete action object found!
+          const actionJSON = this.buffer.substring(objectStart, i + 1);
+          try {
+            const action = JSON.parse(actionJSON);
+            actions.push(action);
+            this.parsedActions++;
+            this.lastParsedIndex = i + 1;
+
+            if (process.env.KOI_DEBUG_LLM) {
+              console.error(`[IncrementalParser] ✅ Parsed action #${this.parsedActions}: ${action.intent || action.type || 'unknown'}`);
+            }
+          } catch (e) {
+            // Failed to parse - might be incomplete, wait for more data
+            if (process.env.KOI_DEBUG_LLM) {
+              console.error(`[IncrementalParser] ⚠️  Failed to parse object at ${objectStart}: ${e.message}`);
+            }
+          }
+          objectStart = -1;
+        }
+      } else if (char === ']' && depth === 0) {
+        // End of actions array
+        if (process.env.KOI_DEBUG_LLM) {
+          console.error(`[IncrementalParser] 🏁 End of actions array reached`);
+        }
+        break;
+      }
+    }
+
+    return actions;
+  }
+
+  /**
+   * Signal end of stream - parse any remaining content
+   */
+  finalize() {
+    const actions = [];
+
+    // If we have unparsed content, try one final parse
+    if (this.lastParsedIndex < this.buffer.length) {
+      if (process.env.KOI_DEBUG_LLM) {
+        console.error(`[IncrementalParser] Finalizing - ${this.buffer.length - this.lastParsedIndex} chars remaining`);
+      }
+
+      // Try to find any remaining complete objects
+      const remaining = this.buffer.substring(this.lastParsedIndex);
+      const objects = this.extractObjects(remaining);
+      actions.push(...objects);
+    }
+
+    return actions;
+  }
+
+  /**
+   * Extract complete JSON objects from a string
+   */
+  extractObjects(str) {
+    const objects = [];
+    let depth = 0;
+    let inString = false;
+    let escapeNext = false;
+    let objectStart = -1;
+
+    for (let i = 0; i < str.length; i++) {
+      const char = str[i];
+
+      if (escapeNext) {
+        escapeNext = false;
+        continue;
+      }
+
+      if (char === '\\' && inString) {
+        escapeNext = true;
+        continue;
+      }
+
+      if (char === '"') {
+        inString = !inString;
+        continue;
+      }
+
+      if (inString) continue;
+
+      if (char === '{') {
+        if (depth === 0) objectStart = i;
+        depth++;
+      } else if (char === '}') {
+        depth--;
+        if (depth === 0 && objectStart !== -1) {
+          try {
+            const obj = JSON.parse(str.substring(objectStart, i + 1));
+            objects.push(obj);
+          } catch (e) {
+            // Ignore parse errors in finalize
+          }
+          objectStart = -1;
+        }
+      }
+    }
+
+    return objects;
+  }
+
+  /**
+   * Reset parser state for new stream
+   */
+  reset() {
+    this.buffer = '';
+    this.actionsStartIndex = -1;
+    this.lastParsedIndex = 0;
+    this.parsedActions = 0;
+  }
+}

package/src/runtime/index.js

@@ -0,0 +1,33 @@
+export { Agent } from './agent.js';
+export { Team } from './team.js';
+export { Skill } from './skill.js';
+export { Role } from './role.js';
+export { Runtime } from './runtime.js';
+export { MCPClient, mcpClient } from './mcp-client.js';
+export { Planner, PlanningAgent } from './planner.js';
+export { SkillSelector, skillSelector } from './skill-selector.js';
+export { registry, getRegistry } from './registry.js';
+
+// Global registry for skill functions (for tool calling)
+export const SkillRegistry = {
+  _functions: {},
+
+  register(skillName, functionName, fn, metadata = {}) {
+    if (!this._functions[skillName]) {
+      this._functions[skillName] = {};
+    }
+    this._functions[skillName][functionName] = { fn, metadata };
+  },
+
+  get(skillName, functionName) {
+    return this._functions[skillName]?.[functionName];
+  },
+
+  getAll(skillName) {
+    return this._functions[skillName] || {};
+  },
+
+  getAllSkills() {
+    return this._functions;
+  }
+};