@docscode/core 1.0.0 → 1.0.1

package/src/StreamBuffer.ts

@@ -1,60 +0,0 @@
-import * as Y from 'yjs';
-
-export class StreamBuffer {
-  private text: Y.Text;
-  private clientID: number;
-  private buffer: string = '';
-  private flushInterval: number;
-  private timer: any = null;
-  private currentIndex: number;
-
-  constructor(text: Y.Text, clientID: number, startIndex: number, flushInterval: number = 50) {
-    this.text = text;
-    this.clientID = clientID;
-    this.currentIndex = startIndex;
-    this.flushInterval = flushInterval;
-  }
-
-  /**
-   * Add a new token to the buffer
-   */
-  public push(token: string) {
-    this.buffer += token;
-    if (!this.timer) {
-      this.timer = setTimeout(() => this.flush(), this.flushInterval);
-    }
-  }
-
-  /**
-   * Immediately flush the buffer to the Yjs document
-   */
-  public 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
-   */
-  public stop() {
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = null;
-    }
-  }
-}

package/src/SummarizationPlugin.ts

@@ -1,100 +0,0 @@
-import * as Y from 'yjs';
-import { KairoPlugin } from './KairoPlugin.js';
-import { AICollaborator } from './AICollaborator.js';
-import type { LLMAdapter } from './LLMAdapter.js';
-
-/**
- * SummarizationPlugin — Trigger document summarization with '/summarize' in the text.
- * The AI peer generates a summary and inserts it as a blockquote below the trigger.
- */
-export class SummarizationPlugin extends KairoPlugin {
-  private targetTextName: string;
-  private adapter: LLMAdapter;
-  private _deepObserver: (events: Y.YEvent<any>[]) => void;
-
-  constructor(ai: AICollaborator, adapter: LLMAdapter, targetTextName: string = 'content') {
-    super(ai);
-    this.adapter = adapter;
-    this.targetTextName = targetTextName;
-    this._deepObserver = (events: Y.YEvent<any>[]) => {
-      for (const event of events) {
-        if (event instanceof Y.YTextEvent) {
-          this._handleUpdate(event);
-        }
-      }
-    };
-  }
-
-  public setup() {
-    try {
-      const arr = this.ai.doc.getArray(this.targetTextName);
-      arr.observeDeep(this._deepObserver);
-    } catch { }
-    console.log(`[Kairo] SummarizationPlugin initialized — model: ${this.adapter.model}`);
-  }
-
-  public destroy() {
-    try {
-      const arr = this.ai.doc.getArray(this.targetTextName);
-      arr.unobserveDeep(this._deepObserver);
-    } catch { }
-  }
-
-
-  private _handleUpdate(event: Y.YTextEvent) {
-    if (!this.enabled) return;
-    if (event.transaction.origin === this.ai.clientID) return;
-
-    const text = event.target as Y.Text;
-    const str = text.toString();
-
-    if (str.endsWith('/summarize')) {
-      this._performSummarization(text);
-    }
-  }
-
-  private async _performSummarization(text: Y.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');
-      }
-
-      // Use cache to avoid re-summarizing identical content
-      const cached = this.ai.cache.get(contentToSummarize);
-      const summary = cached ?? await this.adapter.complete(
-        `Summarize the following document concisely in 2-3 sentences:\n\n${contentToSummarize}`,
-        {
-          systemPrompt: 'You are a document summarizer. Output only the summary — 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, `\n\n> **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();
-    }
-  }
-}

package/src/TransformersAdapter.ts

@@ -1,48 +0,0 @@
-import { pipeline } from '@huggingface/transformers';
-import { LLMAdapter } from './LLMAdapter.js';
-
-export class TransformersAdapter implements LLMAdapter {
-  public name = 'transformers.js';
-  private modelName: string;
-  private pipe: any = null;
-
-  constructor(modelName: string = 'Xenova/gpt2') {
-    this.modelName = modelName;
-  }
-
-  public async generate(prompt: string, options: any = {}): Promise<string> {
-    if (!this.pipe) {
-      this.pipe = await pipeline('text-generation', this.modelName);
-    }
-
-    const output = await this.pipe(prompt, {
-      max_new_tokens: 20,
-      do_sample: true,
-      ...options
-    });
-
-    const generatedText = output[0].generated_text;
-    // Extract only the new part if the model returns the whole prompt
-    return generatedText.startsWith(prompt) 
-      ? generatedText.substring(prompt.length) 
-      : generatedText;
-  }
-
-  public async generateStream(prompt: string, onToken: (token: string) => void, options: any = {}): Promise<void> {
-    if (!this.pipe) {
-      this.pipe = await pipeline('text-generation', this.modelName);
-    }
-
-    // Transformers.js supports stream-like output via callbacks in some versions, 
-    // or we can simulate it for now if the specific model doesn't support it natively.
-    // For GPT-2, we'll simulate the stream for the demo, but use the real iterator if available.
-    const result = await this.generate(prompt, options);
-    
-    // Simulate streaming by breaking the result into chunks
-    const chunks = result.split(/(\s+)/);
-    for (const chunk of chunks) {
-      onToken(chunk);
-      await new Promise(resolve => setTimeout(resolve, 30));
-    }
-  }
-}

package/src/adapters/AnthropicAdapter.ts

@@ -1,72 +0,0 @@
-import type { LLMAdapter, StreamOptions } from '../LLMAdapter.js';
-
-/**
- * AnthropicAdapter — Production Claude streaming via raw fetch SSE.
- * Zero SDK dependency. Uses Messages API with streaming.
- */
-export class AnthropicAdapter implements LLMAdapter {
-  readonly provider = 'anthropic';
-  readonly model: string;
-  private apiKey: string;
-
-  constructor(options: { apiKey?: string; model?: string } = {}) {
-    this.apiKey = options.apiKey ?? process.env['ANTHROPIC_API_KEY'] ?? '';
-    this.model = options.model ?? 'claude-3-5-sonnet-20241022';
-  }
-
-  async *stream(prompt: string, options: StreamOptions = {}): AsyncGenerator<string> {
-    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 ?? 2000,
-        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 { /* skip */ }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  }
-
-  async complete(prompt: string, options: StreamOptions = {}): Promise<string> {
-    let out = '';
-    for await (const t of this.stream(prompt, options)) out += t;
-    return out;
-  }
-}

package/src/adapters/GeminiAdapter.ts

@@ -1,72 +0,0 @@
-import type { LLMAdapter, StreamOptions } from '../LLMAdapter.js';
-
-/**
- * GeminiAdapter — Google Gemini streaming via raw fetch SSE.
- * Supports Gemini 2.0 Flash, Gemini 1.5 Pro/Flash.
- * Zero SDK dependency.
- */
-export class GeminiAdapter implements LLMAdapter {
-  readonly provider = 'gemini';
-  readonly model: string;
-  private apiKey: string;
-
-  constructor(options: { apiKey?: string; model?: string } = {}) {
-    this.apiKey = options.apiKey ?? process.env['GOOGLE_AI_API_KEY'] ?? '';
-    this.model = options.model ?? 'gemini-2.0-flash';
-  }
-
-  async *stream(prompt: string, options: StreamOptions = {}): AsyncGenerator<string> {
-    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}\n\n${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 ?? 2000,
-          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 { /* skip */ }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  }
-
-  async complete(prompt: string, options: StreamOptions = {}): Promise<string> {
-    let out = '';
-    for await (const t of this.stream(prompt, options)) out += t;
-    return out;
-  }
-}

package/src/adapters/OllamaAdapter.ts

@@ -1,81 +0,0 @@
-import type { LLMAdapter, StreamOptions } from '../LLMAdapter.js';
-
-/**
- * OllamaAdapter — Local-first LLM streaming via Ollama REST API.
- * No cloud. No API key. Pure local inference.
- * Works with llama3, mistral, codellama, phi3, gemma2, qwen2.5, etc.
- */
-export class OllamaAdapter implements LLMAdapter {
-  readonly provider = 'ollama';
-  readonly model: string;
-  private baseUrl: string;
-
-  constructor(options: { model?: string; baseUrl?: string } = {}) {
-    this.model = options.model ?? 'llama3.2';
-    this.baseUrl = options.baseUrl ?? 'http://localhost:11434';
-  }
-
-  async *stream(prompt: string, options: StreamOptions = {}): AsyncGenerator<string> {
-    const fullPrompt = options.systemPrompt
-      ? `${options.systemPrompt}\n\nUser: ${prompt}\nAssistant:`
-      : 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 ?? 2000,
-          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) as { response?: string; done?: boolean };
-            if (json.response) yield json.response;
-            if (json.done) return;
-          } catch { /* skip */ }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  }
-
-  async complete(prompt: string, options: StreamOptions = {}): Promise<string> {
-    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(): Promise<boolean> {
-    try {
-      const r = await fetch(`${this.baseUrl}/api/tags`, { signal: AbortSignal.timeout(2000) });
-      if (!r.ok) return false;
-      const json = await r.json() as { models: { name: string }[] };
-      return json.models.some(m => m.name.startsWith(this.model));
-    } catch {
-      return false;
-    }
-  }
-}

package/src/adapters/OpenAIAdapter.ts

@@ -1,87 +0,0 @@
-import type { LLMAdapter, StreamOptions } from '../LLMAdapter.js';
-
-/**
- * OpenAIAdapter — Production streaming adapter using raw fetch (zero SDK).
- * Works with OpenAI API and any OpenAI-compatible endpoint (Together, Groq, etc.)
- */
-export class OpenAIAdapter implements LLMAdapter {
-  readonly provider = 'openai';
-  readonly model: string;
-  private apiKey: string;
-  private baseUrl: string;
-
-  constructor(options: { apiKey?: string; model?: string; baseUrl?: string } = {}) {
-    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: string, options: StreamOptions = {}): AsyncGenerator<string> {
-    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 ?? 2000,
-        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 { /* malformed chunk, skip */ }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  }
-
-  async complete(prompt: string, options: StreamOptions = {}): Promise<string> {
-    let out = '';
-    for await (const t of this.stream(prompt, options)) out += t;
-    return out;
-  }
-
-  async embed(text: string): Promise<number[]> {
-    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() as { data: { embedding: number[] }[] };
-    return json.data[0].embedding;
-  }
-}

package/src/canonical-model.ts

@@ -1,164 +0,0 @@
-import * as Y from 'yjs';
-
-/**
- * Kairo Canonical Document Model — The universal CRDT schema.
- *
- * Every document format (DOCX, PDF, MD, HTML, GDoc) normalizes to this schema.
- * The AI peer reads and writes exclusively via this model.
- *
- * Schema:
- *   metadata: Y.Map  — title, author, format, source, lastModified, etc.
- *   content: Y.Array — ordered array of Block Y.Maps
- *
- * Block structure (Y.Map):
- *   type:  'p' | 'h1'–'h6' | 'li' | 'code' | 'table' | 'blockquote' | 'hr' | 'image'
- *   id:    string (stable UUID for anchor references)
- *   text:  Y.Text (the actual content, with rich attributes for formatting)
- *   meta:  Y.Map (optional, e.g. { lang: 'typescript' } for code blocks)
- *
- * Text attributes (Y.Text marks):
- *   ai-generated:  true         — marks AI-inserted ranges
- *   ai-client-id:  number       — which AI peer inserted this
- *   ai-timestamp:  number       — when
- *   ai-model:      string       — which model
- *   bold / italic / code:       — inline formatting
- */
-
-export type BlockType =
-  | 'p' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6'
-  | 'li' | 'oli' | 'code' | 'table' | 'blockquote' | 'hr' | 'image';
-
-export interface CanonicalBlockMeta {
-  lang?: string;         // code block language
-  level?: number;        // heading level (redundant with type, kept for tooling)
-  src?: string;          // image src
-  alt?: string;          // image alt text
-  aiConfidence?: number; // confidence score for AI-generated blocks
-  [key: string]: unknown;
-}
-
-export class CanonicalDoc {
-  constructor(public readonly yDoc: Y.Doc) {
-    // Ensure maps exist on construction
-    this.yDoc.getMap('metadata');
-    this.yDoc.getArray('content');
-  }
-
-  get metadata(): Y.Map<any> {
-    return this.yDoc.getMap('metadata');
-  }
-
-  get content(): Y.Array<any> {
-    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: BlockType | string, text: string = '', meta?: CanonicalBlockMeta): Y.Text {
-    const block = new Y.Map<any>();
-    const yText = new Y.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 Y.Map<any>();
-      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: string = ''): Y.Text {
-    return this.addBlock('p', text);
-  }
-
-  /** Convenience: add a heading block */
-  addHeading(level: 1 | 2 | 3 | 4 | 5 | 6, text: string): Y.Text {
-    return this.addBlock(`h${level}`, text);
-  }
-
-  /** Set or update metadata on an existing block's Y.Text */
-  setBlockMeta(yText: Y.Text, meta: CanonicalBlockMeta): void {
-    // Walk blocks to find the one owning this Y.Text
-    for (const block of this.content.toArray()) {
-      if (block.get('text') === yText) {
-        let yMeta = block.get('meta') as Y.Map<any> | undefined;
-        if (!yMeta) {
-          yMeta = new Y.Map<any>();
-          block.set('meta', yMeta);
-        }
-        for (const [k, v] of Object.entries(meta)) {
-          yMeta.set(k, v);
-        }
-        return;
-      }
-    }
-  }
-
-  /** Get block by index */
-  getBlock(index: number): Y.Map<any> | undefined {
-    return this.content.get(index);
-  }
-
-  /** Find block by id */
-  findById(id: string): Y.Map<any> | undefined {
-    return this.content.toArray().find(b => b.get('id') === id);
-  }
-
-  /** Get all text content as plain string */
-  toPlainText(): string {
-    return this.content.toArray()
-      .map(block => {
-        const yText = block.get('text') as Y.Text | undefined;
-        return yText?.toString() ?? '';
-      })
-      .filter(Boolean)
-      .join('\n\n');
-  }
-
-  /** Get document stats */
-  stats(): { blockCount: number; charCount: number; wordCount: number } {
-    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(): { charCount: number; blockCount: number } {
-    let charCount = 0;
-    let blockCount = 0;
-
-    for (const block of this.content.toArray()) {
-      const yText = block.get('text') as Y.Text | undefined;
-      if (!yText) continue;
-
-      let blockHasAI = false;
-      // Walk deltas to count AI-attributed characters
-      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 };
-  }
-}