@docscode/core 1.0.0 → 1.0.1

package/dist/index.cjs

@@ -0,0 +1,1166 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AICollaborator: () => AICollaborator,
+  AnthropicAdapter: () => AnthropicAdapter,
+  AutocompletePlugin: () => AutocompletePlugin,
+  CanonicalDoc: () => CanonicalDoc,
+  ConflictResolver: () => ConflictResolver,
+  DoclingClient: () => DoclingClient,
+  GeminiAdapter: () => GeminiAdapter,
+  Kairo: () => Kairo,
+  KairoSession: () => KairoSession,
+  MergePolicy: () => MergePolicy,
+  MockLLMAdapter: () => MockLLMAdapter,
+  OllamaAdapter: () => OllamaAdapter,
+  OpenAIAdapter: () => OpenAIAdapter,
+  PromptCache: () => PromptCache,
+  StreamBuffer: () => StreamBuffer,
+  SuggestionManager: () => SuggestionManager,
+  SummarizationPlugin: () => SummarizationPlugin,
+  kairo: () => kairo
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../../node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/kairo.ts
+var Y4 = __toESM(require("yjs"), 1);
+
+// src/PromptCache.ts
+var PromptCache = class {
+  cache;
+  maxSize;
+  totalHits = 0;
+  totalMisses = 0;
+  constructor(maxSize = 100) {
+    this.maxSize = maxSize;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  /** Retrieve cached result for a prompt. Returns null on miss. */
+  get(prompt) {
+    const entry = this.cache.get(prompt);
+    if (!entry) {
+      this.totalMisses++;
+      return null;
+    }
+    this.cache.delete(prompt);
+    entry.hits++;
+    this.cache.set(prompt, entry);
+    this.totalHits++;
+    return entry.value;
+  }
+  /** Cache a result for a prompt. Evicts LRU entry if at capacity. */
+  set(prompt, value) {
+    if (this.cache.has(prompt)) {
+      this.cache.delete(prompt);
+    } else if (this.cache.size >= this.maxSize) {
+      const lruKey = this.cache.keys().next().value;
+      if (lruKey !== void 0) this.cache.delete(lruKey);
+    }
+    this.cache.set(prompt, { value, hits: 0, createdAt: Date.now() });
+  }
+  /** Check if a prompt is cached without counting as a hit */
+  has(prompt) {
+    return this.cache.has(prompt);
+  }
+  /** Remove a specific entry */
+  invalidate(prompt) {
+    this.cache.delete(prompt);
+  }
+  /** Clear all entries */
+  clear() {
+    this.cache.clear();
+    this.totalHits = 0;
+    this.totalMisses = 0;
+  }
+  /** Cache statistics */
+  stats() {
+    const total = this.totalHits + this.totalMisses;
+    return {
+      size: this.cache.size,
+      maxSize: this.maxSize,
+      hitRate: total > 0 ? this.totalHits / total : 0,
+      totalHits: this.totalHits,
+      totalMisses: this.totalMisses
+    };
+  }
+};
+
+// src/StreamBuffer.ts
+var StreamBuffer = class {
+  text;
+  clientID;
+  buffer = "";
+  flushInterval;
+  timer = null;
+  currentIndex;
+  constructor(text, clientID, startIndex, flushInterval = 50) {
+    this.text = text;
+    this.clientID = clientID;
+    this.currentIndex = startIndex;
+    this.flushInterval = flushInterval;
+  }
+  /**
+   * Add a new token to the buffer
+   */
+  push(token) {
+    this.buffer += token;
+    if (!this.timer) {
+      this.timer = setTimeout(() => this.flush(), this.flushInterval);
+    }
+  }
+  /**
+   * Immediately flush the buffer to the Yjs document
+   */
+  flush() {
+    if (this.buffer.length === 0) {
+      this.timer = null;
+      return;
+    }
+    const contentToInsert = this.buffer;
+    this.buffer = "";
+    this.text.doc?.transact(() => {
+      this.text.insert(this.currentIndex, contentToInsert, {
+        "ai-generated": true,
+        "ai-client-id": this.clientID
+      });
+      this.currentIndex += contentToInsert.length;
+    }, this.clientID);
+    this.timer = null;
+  }
+  /**
+   * Stop any pending flushes
+   */
+  stop() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+};
+
+// src/suggestion-manager.ts
+var SuggestionManager = class {
+  constructor(doc) {
+    this.doc = doc;
+    this.suggestions = doc.getMap("kairo-suggestions");
+  }
+  doc;
+  suggestions;
+  addSuggestion(suggestion) {
+    const id = Math.random().toString(36).substring(7);
+    const fullSuggestion = {
+      ...suggestion,
+      id,
+      timestamp: Date.now()
+    };
+    this.suggestions.set(id, fullSuggestion);
+    return id;
+  }
+  getSuggestions() {
+    return Array.from(this.suggestions.values());
+  }
+  resolveSuggestion(id, accept) {
+    const suggestion = this.suggestions.get(id);
+    if (!suggestion) return;
+    if (accept) {
+    }
+    this.suggestions.delete(id);
+  }
+};
+
+// src/AICollaborator.ts
+var AICollaborator = class {
+  doc;
+  awareness;
+  clientID;
+  suggestions;
+  cache;
+  _status = "idle";
+  _plugins = [];
+  _llm;
+  _streamFlushMs;
+  constructor(doc, awareness, options = {}) {
+    this.doc = doc;
+    this.awareness = awareness;
+    this.clientID = options.clientID ?? Math.floor(Math.random() * 1e6);
+    this.cache = new PromptCache(options.cacheSize ?? 50);
+    this.suggestions = new SuggestionManager(this.doc);
+    this._llm = options.llm;
+    this._streamFlushMs = options.streamFlushMs ?? 50;
+    this._updateAwareness();
+    console.log(`[Kairo] AICollaborator initialized \u2014 clientID: ${this.clientID}, model: ${this._llm?.model ?? "none"}`);
+  }
+  // ─── Status ──────────────────────────────────────────────────────────
+  setStatus(status) {
+    this._status = status;
+    this._updateAwareness();
+  }
+  setThinking() {
+    this.setStatus("thinking");
+  }
+  setWriting() {
+    this.setStatus("writing");
+  }
+  setReviewing() {
+    this.setStatus("reviewing");
+  }
+  setIdle() {
+    this.setStatus("idle");
+  }
+  _updateAwareness() {
+    this.awareness.setLocalStateField("kairo", {
+      status: this._status,
+      metadata: {
+        name: "Kairo",
+        version: "1.0.0",
+        capabilities: ["autocomplete", "summarization", "streaming", "tracked-changes"],
+        model: this._llm?.model
+      },
+      lastUpdate: Date.now()
+    });
+  }
+  // ─── Plugin System ────────────────────────────────────────────────────
+  registerPlugin(plugin) {
+    this._plugins.push(plugin);
+    plugin.setup();
+  }
+  // ─── CRDT Write Operations ────────────────────────────────────────────
+  /**
+   * Insert text with AI attribution markers.
+   * Consuming editors can style/filter AI-generated content using these markers.
+   */
+  insertWithAttribution(text, index, content) {
+    this.doc.transact(() => {
+      text.insert(index, content, {
+        "ai-generated": true,
+        "ai-client-id": this.clientID,
+        "ai-timestamp": Date.now(),
+        "ai-model": this._llm?.model ?? "unknown"
+      });
+    }, this.clientID);
+  }
+  /**
+   * Stream LLM tokens directly into the document as CRDT operations.
+   *
+   * Modes:
+   * - 'insert': appends after current position
+   * - 'continue': appends to end of document
+   * - 'rewrite': clears existing text and rewrites
+   *
+   * Token cadence: tokens are batched with a 50ms flush interval for
+   * smooth real-time rendering without CRDT overload.
+   */
+  async streamToDoc(yText, prompt, options = {}) {
+    if (!this._llm) {
+      throw new Error("[Kairo] No LLM configured. Pass llm to AICollaborator constructor.");
+    }
+    const startTime = Date.now();
+    const mode = options.mode ?? "continue";
+    let startIndex;
+    if (mode === "rewrite") {
+      this.doc.transact(() => yText.delete(0, yText.length));
+      startIndex = 0;
+    } else if (mode === "insert" && options.insertAt !== void 0) {
+      startIndex = options.insertAt;
+    } else {
+      startIndex = yText.length;
+    }
+    const buffer = new StreamBuffer(yText, this.clientID, startIndex, this._streamFlushMs);
+    this.setThinking();
+    let tokensWritten = 0;
+    try {
+      const systemPrompt = options.systemPrompt ?? "You are Kairo, an AI writing collaborator embedded in a shared document. Output clean prose only. No preamble, no meta-commentary.";
+      this.setWriting();
+      for await (const token of this._llm.stream(prompt, {
+        systemPrompt,
+        signal: options.signal
+      })) {
+        buffer.push(token);
+        tokensWritten += token.length;
+        options.onToken?.(token);
+      }
+      buffer.flush();
+    } catch (err) {
+      buffer.stop();
+      this.setIdle();
+      throw err;
+    }
+    buffer.stop();
+    this.setIdle();
+    return { tokensWritten, durationMs: Date.now() - startTime };
+  }
+  /**
+   * One-shot: summarize a block of text and return the result (no streaming).
+   */
+  async summarize(text, options = {}) {
+    if (!this._llm) throw new Error("[Kairo] No LLM configured.");
+    const cached = this.cache.get(text);
+    if (cached) return cached;
+    this.setThinking();
+    try {
+      const result = await this._llm.complete(
+        `Summarize the following document content concisely:
+
+${text}`,
+        {
+          systemPrompt: "You are a document summarization engine. Output only the summary.",
+          maxTokens: options.maxTokens ?? 300
+        }
+      );
+      this.cache.set(text, result);
+      return result;
+    } finally {
+      this.setIdle();
+    }
+  }
+  // ─── Cleanup ──────────────────────────────────────────────────────────
+  destroy() {
+    this._plugins.forEach((p) => p.destroy());
+    this.awareness.setLocalStateField("kairo", null);
+    console.log(`[Kairo] AICollaborator ${this.clientID} destroyed.`);
+  }
+};
+
+// src/AutocompletePlugin.ts
+var Y = __toESM(require("yjs"), 1);
+
+// src/KairoPlugin.ts
+var KairoPlugin = class {
+  ai;
+  enabled = true;
+  constructor(ai) {
+    this.ai = ai;
+  }
+  /**
+   * Enable/Disable the plugin
+   */
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+};
+
+// src/AutocompletePlugin.ts
+var AutocompletePlugin = class extends KairoPlugin {
+  targetTextName;
+  adapter;
+  _deepObserver;
+  constructor(ai, adapter, targetTextName = "content") {
+    super(ai);
+    this.adapter = adapter;
+    this.targetTextName = targetTextName;
+    this._deepObserver = (events) => {
+      for (const event of events) {
+        if (event instanceof Y.YTextEvent) {
+          this._handleUpdate(event);
+        }
+      }
+    };
+  }
+  setup() {
+    try {
+      const arr = this.ai.doc.getArray(this.targetTextName);
+      arr.observeDeep(this._deepObserver);
+    } catch {
+    }
+    console.log(`[Kairo] AutocompletePlugin initialized \u2014 model: ${this.adapter.model}`);
+  }
+  destroy() {
+    try {
+      const arr = this.ai.doc.getArray(this.targetTextName);
+      arr.unobserveDeep(this._deepObserver);
+    } catch {
+    }
+  }
+  _handleUpdate(event) {
+    if (!this.enabled) return;
+    if (event.transaction.origin === this.ai.clientID) return;
+    const text = event.target;
+    const str = text.toString();
+    if (str.endsWith("...")) {
+      this._generateSuggestion(text);
+    }
+  }
+  async _generateSuggestion(text) {
+    this.ai.setThinking();
+    try {
+      const currentText = text.toString();
+      const prompt = currentText.slice(0, -3);
+      const cached = this.ai.cache.get(prompt);
+      if (cached) {
+        this.ai.doc.transact(() => {
+          text.delete(text.length - 3, 3);
+          text.insert(text.length, cached, { "ai-generated": true, "ai-client-id": this.ai.clientID });
+        }, this.ai.clientID);
+        return;
+      }
+      this.ai.doc.transact(() => {
+        text.delete(text.length - 3, 3);
+      }, this.ai.clientID);
+      this.ai.setWriting();
+      const streamBuffer = new StreamBuffer(text, this.ai.clientID, text.length);
+      let fullResult = "";
+      const systemPrompt = "You are an inline writing assistant. Continue the text naturally in the same style and voice. Output only the continuation \u2014 no preamble.";
+      for await (const token of this.adapter.stream(prompt, { systemPrompt })) {
+        fullResult += token;
+        streamBuffer.push(token);
+      }
+      streamBuffer.flush();
+      this.ai.cache.set(prompt, fullResult);
+    } catch (error) {
+      console.error("[Kairo] Autocomplete error:", error);
+    } finally {
+      this.ai.setIdle();
+    }
+  }
+};
+
+// src/SummarizationPlugin.ts
+var Y2 = __toESM(require("yjs"), 1);
+var SummarizationPlugin = class extends KairoPlugin {
+  targetTextName;
+  adapter;
+  _deepObserver;
+  constructor(ai, adapter, targetTextName = "content") {
+    super(ai);
+    this.adapter = adapter;
+    this.targetTextName = targetTextName;
+    this._deepObserver = (events) => {
+      for (const event of events) {
+        if (event instanceof Y2.YTextEvent) {
+          this._handleUpdate(event);
+        }
+      }
+    };
+  }
+  setup() {
+    try {
+      const arr = this.ai.doc.getArray(this.targetTextName);
+      arr.observeDeep(this._deepObserver);
+    } catch {
+    }
+    console.log(`[Kairo] SummarizationPlugin initialized \u2014 model: ${this.adapter.model}`);
+  }
+  destroy() {
+    try {
+      const arr = this.ai.doc.getArray(this.targetTextName);
+      arr.unobserveDeep(this._deepObserver);
+    } catch {
+    }
+  }
+  _handleUpdate(event) {
+    if (!this.enabled) return;
+    if (event.transaction.origin === this.ai.clientID) return;
+    const text = event.target;
+    const str = text.toString();
+    if (str.endsWith("/summarize")) {
+      this._performSummarization(text);
+    }
+  }
+  async _performSummarization(text) {
+    this.ai.setThinking();
+    try {
+      const fullText = text.toString();
+      const TRIGGER = "/summarize";
+      const contentToSummarize = fullText.slice(0, -TRIGGER.length).trim();
+      if (contentToSummarize.length < 20) {
+        throw new Error("Content too short to summarize");
+      }
+      const cached = this.ai.cache.get(contentToSummarize);
+      const summary = cached ?? await this.adapter.complete(
+        `Summarize the following document concisely in 2-3 sentences:
+
+${contentToSummarize}`,
+        {
+          systemPrompt: "You are a document summarizer. Output only the summary \u2014 no preamble.",
+          maxTokens: 150
+        }
+      );
+      if (!cached) {
+        this.ai.cache.set(contentToSummarize, summary);
+      }
+      this.ai.setWriting();
+      this.ai.doc.transact(() => {
+        const idx = text.length - TRIGGER.length;
+        text.delete(idx, TRIGGER.length);
+        text.insert(idx, `
+
+> **AI Summary:** ${summary.trim()}`, {
+          "ai-generated": true,
+          "ai-client-id": this.ai.clientID,
+          "ai-timestamp": Date.now()
+        });
+      }, this.ai.clientID);
+    } catch (error) {
+      console.error("[Kairo] Summarization error:", error);
+    } finally {
+      this.ai.setIdle();
+    }
+  }
+};
+
+// src/ConflictResolver.ts
+var Y3 = __toESM(require("yjs"), 1);
+var ConflictResolver = class {
+  constructor(doc, aiClientIds = []) {
+    this.doc = doc;
+    this.aiClientIds = new Set(aiClientIds);
+    this._observe();
+  }
+  doc;
+  conflictLog = [];
+  handlers = [];
+  aiClientIds;
+  /** Register a client ID as an AI participant */
+  registerAI(clientId) {
+    this.aiClientIds.add(clientId);
+  }
+  /** Listen for conflict events */
+  onConflict(handler) {
+    this.handlers.push(handler);
+  }
+  /** Get the conflict log */
+  getLog() {
+    return [...this.conflictLog];
+  }
+  /** Clear the conflict log */
+  clearLog() {
+    this.conflictLog = [];
+  }
+  _observe() {
+    this.doc.on("afterTransaction", (tr) => {
+      if (!tr.changed.size) return;
+      tr.changed.forEach((_changedKeys, type) => {
+        if (!(type instanceof Y3.Text)) return;
+        const origin = tr.origin;
+        const isAI = this.aiClientIds.has(origin);
+        if (!isAI) {
+          const event = {
+            type: "concurrent_edit",
+            position: 0,
+            humanClientId: origin,
+            aiClientId: -1,
+            timestamp: Date.now()
+          };
+          this._emit(event);
+        }
+      });
+    });
+  }
+  _emit(event) {
+    this.conflictLog.push(event);
+    if (this.conflictLog.length > 500) {
+      this.conflictLog = this.conflictLog.slice(-500);
+    }
+    for (const handler of this.handlers) {
+      try {
+        handler(event);
+      } catch {
+      }
+    }
+  }
+};
+var MergePolicy = class {
+  static HUMAN_WINS = "human_wins";
+  static LAST_WRITE_WINS = "last_write_wins";
+  static AI_WINS = "ai_wins";
+  static isAIGenerated(attrs) {
+    return attrs?.["ai-generated"] === true;
+  }
+  static getAuthor(attrs) {
+    return this.isAIGenerated(attrs) ? "ai" : "human";
+  }
+};
+
+// src/kairo.ts
+var import_awareness = require("y-protocols/awareness");
+var KairoSession = class {
+  constructor(doc, ai, adapter, conflictResolver) {
+    this.doc = doc;
+    this.ai = ai;
+    this._adapter = adapter;
+    this.conflictResolver = conflictResolver;
+  }
+  doc;
+  ai;
+  conflictResolver;
+  _adapter;
+  /** Export the document back to its original format */
+  async export() {
+    if (!this._adapter) throw new Error("[Kairo] No format adapter \u2014 cannot export.");
+    return this._adapter.write(this.doc);
+  }
+  /** Get the plain text content of the document */
+  getText(key = "content") {
+    return this.doc.getText(key).toString();
+  }
+  /** Get word count */
+  wordCount() {
+    return this.getText().split(/\s+/).filter(Boolean).length;
+  }
+  /** Destroy the session and free resources */
+  destroy() {
+    this.ai.destroy();
+    this.doc.destroy();
+  }
+};
+var Kairo = class {
+  formatAdapters = /* @__PURE__ */ new Map();
+  /** Register a format adapter (DOCX, PDF, MD, HTML, GDoc, etc.) */
+  registerFormatAdapter(adapter) {
+    this.formatAdapters.set(adapter.format, adapter);
+    return this;
+  }
+  /** Connect to a document and start an AI session */
+  async connect(options) {
+    const format = options.format ?? this._detectFormat(options.fileName ?? "");
+    const adapter = options.adapter ?? this.formatAdapters.get(format);
+    let doc;
+    if (adapter) {
+      doc = await adapter.read(options.content);
+    } else {
+      doc = new Y4.Doc();
+      const text = typeof options.content === "string" ? options.content : options.content.toString("utf-8");
+      doc.getText("content").insert(0, text);
+    }
+    const awareness = new import_awareness.Awareness(doc);
+    const ai = new AICollaborator(doc, awareness, {
+      llm: options.llm,
+      clientID: options.clientId,
+      streamFlushMs: options.streamFlushMs
+    });
+    const behaviors = options.behaviors ?? ["autocomplete", "summarize"];
+    if (options.llm) {
+      if (behaviors.includes("autocomplete")) ai.registerPlugin(new AutocompletePlugin(ai, options.llm));
+      if (behaviors.includes("summarize")) ai.registerPlugin(new SummarizationPlugin(ai, options.llm));
+    }
+    let conflictResolver;
+    if (options.conflictResolution !== false) {
+      conflictResolver = new ConflictResolver(doc, [ai.clientID]);
+    }
+    return new KairoSession(doc, ai, adapter, conflictResolver);
+  }
+  /** Open multiple documents concurrently */
+  async connectAll(configs) {
+    return Promise.all(configs.map((c) => this.connect(c)));
+  }
+  _detectFormat(file) {
+    if (typeof file !== "string") return "txt";
+    const ext = file.split(".").pop()?.toLowerCase() ?? "";
+    const map = {
+      docx: "docx",
+      pdf: "pdf",
+      md: "markdown",
+      markdown: "markdown",
+      html: "html",
+      htm: "html",
+      txt: "txt"
+    };
+    return map[ext] ?? "txt";
+  }
+};
+var kairo = new Kairo();
+
+// src/adapters/OpenAIAdapter.ts
+var OpenAIAdapter = class {
+  provider = "openai";
+  model;
+  apiKey;
+  baseUrl;
+  constructor(options = {}) {
+    this.apiKey = options.apiKey ?? process.env["OPENAI_API_KEY"] ?? "";
+    this.model = options.model ?? "gpt-4o-mini";
+    this.baseUrl = options.baseUrl ?? "https://api.openai.com/v1";
+  }
+  async *stream(prompt, options = {}) {
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: this.model,
+        messages: [
+          ...options.systemPrompt ? [{ role: "system", content: options.systemPrompt }] : [],
+          { role: "user", content: prompt }
+        ],
+        max_tokens: options.maxTokens ?? 2e3,
+        temperature: options.temperature ?? 0.7,
+        stream: true
+      }),
+      signal: options.signal
+    });
+    if (!response.ok) {
+      const err = await response.text();
+      throw new Error(`[Kairo/OpenAI] API error ${response.status}: ${err}`);
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buf = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buf += decoder.decode(value, { stream: true });
+        const lines = buf.split("\n");
+        buf = lines.pop() ?? "";
+        for (const line of lines) {
+          const t = line.trim();
+          if (!t || t === "data: [DONE]") continue;
+          if (!t.startsWith("data: ")) continue;
+          try {
+            const json = JSON.parse(t.slice(6));
+            const token = json.choices?.[0]?.delta?.content;
+            if (token) yield token;
+          } catch {
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  async complete(prompt, options = {}) {
+    let out = "";
+    for await (const t of this.stream(prompt, options)) out += t;
+    return out;
+  }
+  async embed(text) {
+    const r = await fetch(`${this.baseUrl}/embeddings`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${this.apiKey}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ model: "text-embedding-3-small", input: text })
+    });
+    if (!r.ok) throw new Error(`[Kairo/OpenAI] Embed error ${r.status}`);
+    const json = await r.json();
+    return json.data[0].embedding;
+  }
+};
+
+// src/adapters/AnthropicAdapter.ts
+var AnthropicAdapter = class {
+  provider = "anthropic";
+  model;
+  apiKey;
+  constructor(options = {}) {
+    this.apiKey = options.apiKey ?? process.env["ANTHROPIC_API_KEY"] ?? "";
+    this.model = options.model ?? "claude-3-5-sonnet-20241022";
+  }
+  async *stream(prompt, options = {}) {
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: this.model,
+        max_tokens: options.maxTokens ?? 2e3,
+        system: options.systemPrompt ?? "You are Kairo, an AI document collaborator.",
+        messages: [{ role: "user", content: prompt }],
+        stream: true
+      }),
+      signal: options.signal
+    });
+    if (!response.ok) {
+      const err = await response.text();
+      throw new Error(`[Kairo/Anthropic] API error ${response.status}: ${err}`);
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buf = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buf += decoder.decode(value, { stream: true });
+        const lines = buf.split("\n");
+        buf = lines.pop() ?? "";
+        for (const line of lines) {
+          const t = line.trim();
+          if (!t.startsWith("data: ")) continue;
+          try {
+            const json = JSON.parse(t.slice(6));
+            if (json.type === "content_block_delta" && json.delta?.text) {
+              yield json.delta.text;
+            }
+          } catch {
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  async complete(prompt, options = {}) {
+    let out = "";
+    for await (const t of this.stream(prompt, options)) out += t;
+    return out;
+  }
+};
+
+// src/adapters/OllamaAdapter.ts
+var OllamaAdapter = class {
+  provider = "ollama";
+  model;
+  baseUrl;
+  constructor(options = {}) {
+    this.model = options.model ?? "llama3.2";
+    this.baseUrl = options.baseUrl ?? "http://localhost:11434";
+  }
+  async *stream(prompt, options = {}) {
+    const fullPrompt = options.systemPrompt ? `${options.systemPrompt}
+
+User: ${prompt}
+Assistant:` : prompt;
+    const response = await fetch(`${this.baseUrl}/api/generate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: this.model,
+        prompt: fullPrompt,
+        stream: true,
+        options: {
+          num_predict: options.maxTokens ?? 2e3,
+          temperature: options.temperature ?? 0.7
+        }
+      }),
+      signal: options.signal
+    });
+    if (!response.ok) {
+      throw new Error(`[Kairo/Ollama] Error ${response.status}. Is Ollama running at ${this.baseUrl}?`);
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const text = decoder.decode(value);
+        for (const line of text.split("\n")) {
+          if (!line.trim()) continue;
+          try {
+            const json = JSON.parse(line);
+            if (json.response) yield json.response;
+            if (json.done) return;
+          } catch {
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  async complete(prompt, options = {}) {
+    let out = "";
+    for await (const t of this.stream(prompt, options)) out += t;
+    return out;
+  }
+  /** Check if Ollama is running and model is available */
+  async isAvailable() {
+    try {
+      const r = await fetch(`${this.baseUrl}/api/tags`, { signal: AbortSignal.timeout(2e3) });
+      if (!r.ok) return false;
+      const json = await r.json();
+      return json.models.some((m) => m.name.startsWith(this.model));
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/adapters/GeminiAdapter.ts
+var GeminiAdapter = class {
+  provider = "gemini";
+  model;
+  apiKey;
+  constructor(options = {}) {
+    this.apiKey = options.apiKey ?? process.env["GOOGLE_AI_API_KEY"] ?? "";
+    this.model = options.model ?? "gemini-2.0-flash";
+  }
+  async *stream(prompt, options = {}) {
+    const url = `https://generativelanguage.googleapis.com/v1beta/models/${this.model}:streamGenerateContent?alt=sse&key=${this.apiKey}`;
+    const contents = options.systemPrompt ? [{ role: "user", parts: [{ text: `${options.systemPrompt}
+
+${prompt}` }] }] : [{ role: "user", parts: [{ text: prompt }] }];
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        contents,
+        generationConfig: {
+          maxOutputTokens: options.maxTokens ?? 2e3,
+          temperature: options.temperature ?? 0.7
+        }
+      }),
+      signal: options.signal
+    });
+    if (!response.ok) {
+      throw new Error(`[Kairo/Gemini] Error ${response.status}: ${await response.text()}`);
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buf = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buf += decoder.decode(value, { stream: true });
+        const lines = buf.split("\n");
+        buf = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          try {
+            const json = JSON.parse(line.slice(6));
+            const text = json.candidates?.[0]?.content?.parts?.[0]?.text;
+            if (text) yield text;
+          } catch {
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  async complete(prompt, options = {}) {
+    let out = "";
+    for await (const t of this.stream(prompt, options)) out += t;
+    return out;
+  }
+};
+
+// src/MockLLMAdapter.ts
+var MockLLMAdapter = class {
+  provider = "mock";
+  model;
+  delay;
+  constructor(options = {}) {
+    this.model = options.model ?? "mock-gpt";
+    this.delay = options.delay ?? 100;
+  }
+  async *stream(prompt, options) {
+    const response = this._respond(prompt);
+    const words = response.split(" ");
+    for (let i = 0; i < words.length; i++) {
+      await new Promise((r) => setTimeout(r, this.delay / words.length));
+      yield words[i] + (i < words.length - 1 ? " " : "");
+    }
+  }
+  async complete(prompt, options) {
+    await new Promise((r) => setTimeout(r, this.delay));
+    return this._respond(prompt);
+  }
+  async embed(text) {
+    return Array.from({ length: 128 }, (_, i) => Math.sin(text.charCodeAt(i % text.length) * (i + 1)));
+  }
+  _respond(prompt) {
+    const p = prompt.toLowerCase();
+    if (p.includes("summar")) return "This document discusses key concepts with clarity and precision.";
+    if (p.includes("improve") || p.includes("rewrite")) return "The refined version presents ideas more effectively.";
+    if (p.includes("continue")) return " Furthermore, the analysis reveals several important implications.";
+    return `[Mock AI response to: "${prompt.slice(0, 60)}..."]`;
+  }
+};
+
+// src/canonical-model.ts
+var Y5 = __toESM(require("yjs"), 1);
+var CanonicalDoc = class {
+  constructor(yDoc) {
+    this.yDoc = yDoc;
+    this.yDoc.getMap("metadata");
+    this.yDoc.getArray("content");
+  }
+  yDoc;
+  get metadata() {
+    return this.yDoc.getMap("metadata");
+  }
+  get content() {
+    return this.yDoc.getArray("content");
+  }
+  // ─── Block Factory ─────────────────────────────────────────────────
+  /**
+   * Add a block to the document.
+   * Returns the Y.Text of the block so callers can further instrument it.
+   */
+  addBlock(type, text = "", meta) {
+    const block = new Y5.Map();
+    const yText = new Y5.Text(text);
+    const id = `blk_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 7)}`;
+    block.set("type", type);
+    block.set("id", id);
+    block.set("text", yText);
+    if (meta) {
+      const yMeta = new Y5.Map();
+      for (const [k, v] of Object.entries(meta)) {
+        yMeta.set(k, v);
+      }
+      block.set("meta", yMeta);
+    }
+    this.content.push([block]);
+    return yText;
+  }
+  /** Convenience: add a paragraph block */
+  addParagraph(text = "") {
+    return this.addBlock("p", text);
+  }
+  /** Convenience: add a heading block */
+  addHeading(level, text) {
+    return this.addBlock(`h${level}`, text);
+  }
+  /** Set or update metadata on an existing block's Y.Text */
+  setBlockMeta(yText, meta) {
+    for (const block of this.content.toArray()) {
+      if (block.get("text") === yText) {
+        let yMeta = block.get("meta");
+        if (!yMeta) {
+          yMeta = new Y5.Map();
+          block.set("meta", yMeta);
+        }
+        for (const [k, v] of Object.entries(meta)) {
+          yMeta.set(k, v);
+        }
+        return;
+      }
+    }
+  }
+  /** Get block by index */
+  getBlock(index) {
+    return this.content.get(index);
+  }
+  /** Find block by id */
+  findById(id) {
+    return this.content.toArray().find((b) => b.get("id") === id);
+  }
+  /** Get all text content as plain string */
+  toPlainText() {
+    return this.content.toArray().map((block) => {
+      const yText = block.get("text");
+      return yText?.toString() ?? "";
+    }).filter(Boolean).join("\n\n");
+  }
+  /** Get document stats */
+  stats() {
+    const text = this.toPlainText();
+    const words = text.split(/\s+/).filter(Boolean);
+    return {
+      blockCount: this.content.length,
+      charCount: text.length,
+      wordCount: words.length
+    };
+  }
+  /** Get AI-contributed character count */
+  aiContributions() {
+    let charCount = 0;
+    let blockCount = 0;
+    for (const block of this.content.toArray()) {
+      const yText = block.get("text");
+      if (!yText) continue;
+      let blockHasAI = false;
+      for (const delta of yText.toDelta()) {
+        if (delta.attributes?.["ai-generated"] && delta.insert) {
+          charCount += delta.insert.length;
+          blockHasAI = true;
+        }
+      }
+      if (blockHasAI) blockCount++;
+    }
+    return { charCount, blockCount };
+  }
+};
+
+// src/docling-client.ts
+var import_child_process = require("child_process");
+var import_path = __toESM(require("path"), 1);
+var import_url = require("url");
+var getDirname = () => {
+  if (typeof __dirname !== "undefined") return __dirname;
+  return import_path.default.dirname((0, import_url.fileURLToPath)(importMetaUrl));
+};
+var _dirname = getDirname();
+var BRIDGE_PATH = import_path.default.join(_dirname, "../scripts/docling_bridge.py");
+var DoclingClient = class {
+  async convert(filePathOrBase64) {
+    return new Promise((resolve, reject) => {
+      const pythonProcess = (0, import_child_process.spawn)("python", [BRIDGE_PATH, filePathOrBase64]);
+      let output = "";
+      let error = "";
+      pythonProcess.stdout.on("data", (data) => {
+        output += data.toString();
+      });
+      pythonProcess.stderr.on("data", (data) => {
+        error += data.toString();
+      });
+      pythonProcess.on("close", (code) => {
+        if (code !== 0) {
+          reject(new Error(`Python process exited with code ${code}: ${error}`));
+          return;
+        }
+        try {
+          const result = JSON.parse(output);
+          if (result.error) {
+            reject(new Error(result.error));
+          } else {
+            resolve(result);
+          }
+        } catch (e) {
+          reject(new Error(`Failed to parse Python output: ${output}`));
+        }
+      });
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AICollaborator,
+  AnthropicAdapter,
+  AutocompletePlugin,
+  CanonicalDoc,
+  ConflictResolver,
+  DoclingClient,
+  GeminiAdapter,
+  Kairo,
+  KairoSession,
+  MergePolicy,
+  MockLLMAdapter,
+  OllamaAdapter,
+  OpenAIAdapter,
+  PromptCache,
+  StreamBuffer,
+  SuggestionManager,
+  SummarizationPlugin,
+  kairo
+});