teleton 0.5.1 → 0.6.0

package/dist/{chunk-BYTHCDZA.js → chunk-ADCMUNYU.js}

@@ -1,143 +1,24 @@
 import {
-  DEFAULT_FETCH_TIMEOUT_MS
-} from "./chunk-4DU3C27M.js";
+  CachedEmbeddingProvider,
+  createEmbeddingProvider,
+  hashText,
+  serializeEmbedding
+} from "./chunk-D5I7GBV7.js";
+import {
+  JOURNAL_SCHEMA
+} from "./chunk-ECSCVEQQ.js";
 import {
-  EMBEDDING_CACHE_EVICTION_INTERVAL,
-  EMBEDDING_CACHE_EVICTION_RATIO,
-  EMBEDDING_CACHE_MAX_ENTRIES,
-  EMBEDDING_CACHE_TTL_DAYS,
   HYBRID_SEARCH_MIN_SCORE,
   KNOWLEDGE_CHUNK_SIZE,
   SQLITE_CACHE_SIZE_KB,
-  SQLITE_MMAP_SIZE,
-  VOYAGE_BATCH_SIZE
-} from "./chunk-O4R7V5Y2.js";
-import {
-  TELETON_ROOT
-} from "./chunk-EYWNOHMJ.js";
+  SQLITE_MMAP_SIZE
+} from "./chunk-RO62LO6Z.js";
 
 // src/memory/database.ts
-import Database2 from "better-sqlite3";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, chmodSync as chmodSync2 } from "fs";
-import { dirname as dirname2 } from "path";
-import * as sqliteVec from "sqlite-vec";
-
-// src/utils/module-db.ts
 import Database from "better-sqlite3";
 import { existsSync, mkdirSync, chmodSync } from "fs";
-import { dirname, join } from "path";
-var JOURNAL_SCHEMA = `
-  CREATE TABLE IF NOT EXISTS journal (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    timestamp INTEGER NOT NULL DEFAULT (unixepoch()),
-    type TEXT NOT NULL CHECK(type IN ('trade', 'gift', 'middleman', 'kol')),
-    action TEXT NOT NULL,
-    asset_from TEXT,
-    asset_to TEXT,
-    amount_from REAL,
-    amount_to REAL,
-    price_ton REAL,
-    counterparty TEXT,
-    platform TEXT,
-    reasoning TEXT,
-    outcome TEXT CHECK(outcome IN ('pending', 'profit', 'loss', 'neutral', 'cancelled')),
-    pnl_ton REAL,
-    pnl_pct REAL,
-    tx_hash TEXT,
-    tool_used TEXT,
-    chat_id TEXT,
-    user_id INTEGER,
-    closed_at INTEGER,
-    created_at INTEGER NOT NULL DEFAULT (unixepoch())
-  );
-
-  CREATE INDEX IF NOT EXISTS idx_journal_type ON journal(type);
-  CREATE INDEX IF NOT EXISTS idx_journal_timestamp ON journal(timestamp DESC);
-  CREATE INDEX IF NOT EXISTS idx_journal_asset_from ON journal(asset_from);
-  CREATE INDEX IF NOT EXISTS idx_journal_outcome ON journal(outcome);
-  CREATE INDEX IF NOT EXISTS idx_journal_type_timestamp ON journal(type, timestamp DESC);
-`;
-var USED_TRANSACTIONS_SCHEMA = `
-  CREATE TABLE IF NOT EXISTS used_transactions (
-    tx_hash TEXT PRIMARY KEY,
-    user_id TEXT NOT NULL,
-    amount REAL NOT NULL,
-    game_type TEXT NOT NULL,
-    used_at INTEGER NOT NULL DEFAULT (unixepoch())
-  );
-
-  CREATE INDEX IF NOT EXISTS idx_used_tx_user ON used_transactions(user_id);
-  CREATE INDEX IF NOT EXISTS idx_used_tx_used_at ON used_transactions(used_at);
-`;
-function openModuleDb(path) {
-  const dir = dirname(path);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  const db = new Database(path);
-  try {
-    chmodSync(path, 384);
-  } catch {
-  }
-  db.pragma("journal_mode = WAL");
-  return db;
-}
-function createDbWrapper(getDb, moduleName) {
-  return function withDb(executor) {
-    return (params, context) => {
-      const moduleDb = getDb();
-      if (!moduleDb) {
-        return Promise.resolve({
-          success: false,
-          error: `${moduleName} module not started`
-        });
-      }
-      return executor(params, { ...context, db: moduleDb });
-    };
-  };
-}
-var MAIN_DB_PATH = join(TELETON_ROOT, "memory.db");
-function migrateFromMainDb(moduleDb, tables) {
-  let totalMigrated = 0;
-  for (const table of tables) {
-    if (!/^[a-z_]+$/.test(table)) {
-      throw new Error(`Invalid table name for migration: "${table}"`);
-    }
-  }
-  for (const table of tables) {
-    try {
-      const row = moduleDb.prepare(`SELECT COUNT(*) as c FROM ${table}`).get();
-      if (row.c > 0) return 0;
-    } catch {
-      continue;
-    }
-  }
-  if (!existsSync(MAIN_DB_PATH)) return 0;
-  try {
-    moduleDb.exec(`ATTACH DATABASE '${MAIN_DB_PATH}' AS main_db`);
-    for (const table of tables) {
-      try {
-        const exists = moduleDb.prepare(`SELECT name FROM main_db.sqlite_master WHERE type='table' AND name=?`).get(table);
-        if (!exists) continue;
-        const src = moduleDb.prepare(`SELECT COUNT(*) as c FROM main_db.${table}`).get();
-        if (src.c === 0) continue;
-        moduleDb.exec(`INSERT OR IGNORE INTO ${table} SELECT * FROM main_db.${table}`);
-        totalMigrated += src.c;
-        console.log(`  \u{1F4E6} Migrated ${src.c} rows from memory.db \u2192 ${table}`);
-      } catch (e) {
-        console.warn(`  \u26A0\uFE0F Could not migrate table ${table}:`, e);
-      }
-    }
-    moduleDb.exec(`DETACH DATABASE main_db`);
-  } catch (e) {
-    console.warn(`\u26A0\uFE0F Migration from memory.db failed:`, e);
-    try {
-      moduleDb.exec(`DETACH DATABASE main_db`);
-    } catch {
-    }
-  }
-  return totalMigrated;
-}
+import { dirname } from "path";
+import * as sqliteVec from "sqlite-vec";
 
 // src/memory/schema.ts
 function compareSemver(a, b) {
@@ -428,7 +309,7 @@ function setSchemaVersion(db, version) {
   `
   ).run(version);
 }
-var CURRENT_SCHEMA_VERSION = "1.10.1";
+var CURRENT_SCHEMA_VERSION = "1.11.0";
 function runMigrations(db) {
   const currentVersion = getSchemaVersion(db);
   if (!currentVersion || versionLessThan(currentVersion, "1.1.0")) {
@@ -576,6 +457,45 @@ function runMigrations(db) {
       throw error;
     }
   }
+  if (!currentVersion || versionLessThan(currentVersion, "1.11.0")) {
+    console.log("\u{1F504} Running migration 1.11.0: Add tool_index tables for Tool RAG");
+    try {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS tool_index (
+          name TEXT PRIMARY KEY,
+          description TEXT NOT NULL,
+          search_text TEXT NOT NULL,
+          updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+        );
+
+        CREATE VIRTUAL TABLE IF NOT EXISTS tool_index_fts USING fts5(
+          search_text,
+          name UNINDEXED,
+          content='tool_index',
+          content_rowid='rowid'
+        );
+
+        CREATE TRIGGER IF NOT EXISTS tool_index_fts_insert AFTER INSERT ON tool_index BEGIN
+          INSERT INTO tool_index_fts(rowid, search_text, name)
+          VALUES (new.rowid, new.search_text, new.name);
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS tool_index_fts_delete AFTER DELETE ON tool_index BEGIN
+          DELETE FROM tool_index_fts WHERE rowid = old.rowid;
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS tool_index_fts_update AFTER UPDATE ON tool_index BEGIN
+          DELETE FROM tool_index_fts WHERE rowid = old.rowid;
+          INSERT INTO tool_index_fts(rowid, search_text, name)
+          VALUES (new.rowid, new.search_text, new.name);
+        END;
+      `);
+      console.log("\u2705 Migration 1.11.0 complete: tool_index tables created");
+    } catch (error) {
+      console.error("\u274C Migration 1.11.0 failed:", error);
+      throw error;
+    }
+  }
   setSchemaVersion(db, CURRENT_SCHEMA_VERSION);
 }
 
@@ -586,15 +506,15 @@ var MemoryDatabase = class {
   vectorReady = false;
   constructor(config) {
     this.config = config;
-    const dir = dirname2(config.path);
-    if (!existsSync2(dir)) {
-      mkdirSync2(dir, { recursive: true });
+    const dir = dirname(config.path);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
     }
-    this.db = new Database2(config.path, {
+    this.db = new Database(config.path, {
       verbose: process.env.DEBUG_SQL ? console.log : void 0
     });
     try {
-      chmodSync2(config.path, 384);
+      chmodSync(config.path, 384);
     } catch {
     }
     this.db.pragma("journal_mode = WAL");
@@ -743,339 +663,9 @@ function closeDatabase() {
   }
 }
 
-// src/memory/embeddings/index.ts
-import { createHash } from "crypto";
-
-// src/memory/embeddings/provider.ts
-var NoopEmbeddingProvider = class {
-  id = "noop";
-  model = "none";
-  dimensions = 0;
-  async embedQuery(_text) {
-    return [];
-  }
-  async embedBatch(_texts) {
-    return [];
-  }
-};
-
-// src/utils/fetch.ts
-var DEFAULT_TIMEOUT_MS = DEFAULT_FETCH_TIMEOUT_MS;
-function fetchWithTimeout(url, init) {
-  const { timeoutMs = DEFAULT_TIMEOUT_MS, ...fetchInit } = init ?? {};
-  if (fetchInit.signal) {
-    return fetch(url, fetchInit);
-  }
-  return fetch(url, {
-    ...fetchInit,
-    signal: AbortSignal.timeout(timeoutMs)
-  });
-}
-
-// src/constants/api-endpoints.ts
-var TONAPI_BASE_URL = "https://tonapi.io/v2";
-var _tonapiKey;
-function setTonapiKey(key) {
-  _tonapiKey = key;
-}
-function tonapiHeaders() {
-  const headers = { Accept: "application/json" };
-  if (_tonapiKey) {
-    headers["Authorization"] = `Bearer ${_tonapiKey}`;
-  }
-  return headers;
-}
-var TONAPI_MAX_RPS = 5;
-var _tonapiTimestamps = [];
-async function waitForTonapiSlot() {
-  const clean = () => {
-    const cutoff = Date.now() - 1e3;
-    while (_tonapiTimestamps.length > 0 && _tonapiTimestamps[0] <= cutoff) {
-      _tonapiTimestamps.shift();
-    }
-  };
-  clean();
-  if (_tonapiTimestamps.length >= TONAPI_MAX_RPS) {
-    const waitMs = _tonapiTimestamps[0] + 1e3 - Date.now() + 50;
-    if (waitMs > 0) await new Promise((r) => setTimeout(r, waitMs));
-    clean();
-  }
-  _tonapiTimestamps.push(Date.now());
-}
-async function tonapiFetch(path, init) {
-  await waitForTonapiSlot();
-  return fetchWithTimeout(`${TONAPI_BASE_URL}${path}`, {
-    ...init,
-    headers: { ...tonapiHeaders(), ...init?.headers }
-  });
-}
-var STONFI_API_BASE_URL = "https://api.ston.fi/v1";
-var GECKOTERMINAL_API_URL = "https://api.geckoterminal.com/api/v2";
-var COINGECKO_API_URL = "https://api.coingecko.com/api/v3";
-var OPENAI_TTS_URL = "https://api.openai.com/v1/audio/speech";
-var ELEVENLABS_TTS_URL = "https://api.elevenlabs.io/v1/text-to-speech";
-var VOYAGE_API_URL = "https://api.voyageai.com/v1";
-
-// src/memory/embeddings/anthropic.ts
-var AnthropicEmbeddingProvider = class {
-  id = "anthropic";
-  model;
-  dimensions;
-  apiKey;
-  baseUrl = VOYAGE_API_URL;
-  constructor(config) {
-    this.apiKey = config.apiKey;
-    this.model = config.model ?? "voyage-3-lite";
-    const dims = {
-      "voyage-3": 1024,
-      "voyage-3-lite": 512,
-      "voyage-code-3": 1024,
-      "voyage-finance-2": 1024,
-      "voyage-multilingual-2": 1024,
-      "voyage-law-2": 1024
-    };
-    this.dimensions = dims[this.model] ?? 512;
-  }
-  async embedQuery(text) {
-    const result = await this.embed([text]);
-    return result[0] ?? [];
-  }
-  async embedBatch(texts) {
-    if (texts.length === 0) return [];
-    const batchSize = VOYAGE_BATCH_SIZE;
-    const results = [];
-    for (let i = 0; i < texts.length; i += batchSize) {
-      const batch = texts.slice(i, i + batchSize);
-      const embeddings = await this.embed(batch);
-      results.push(...embeddings);
-    }
-    return results;
-  }
-  async embed(texts) {
-    const response = await fetchWithTimeout(`${this.baseUrl}/embeddings`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify({
-        input: texts,
-        model: this.model,
-        input_type: "document"
-      })
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Voyage API error: ${response.status} ${error}`);
-    }
-    const data = await response.json();
-    return data.data.map((item) => item.embedding);
-  }
-};
-
-// src/memory/embeddings/local.ts
-import { pipeline } from "@huggingface/transformers";
-var extractorPromise = null;
-function getExtractor(model) {
-  if (!extractorPromise) {
-    console.log(`\u{1F4E6} Loading local embedding model: ${model} \u2026`);
-    extractorPromise = pipeline("feature-extraction", model, {
-      dtype: "fp32"
-    }).then((ext) => {
-      console.log(`\u2705 Local embedding model ready`);
-      return ext;
-    }).catch((err) => {
-      console.error(`\u274C Failed to load embedding model: ${err.message}`);
-      extractorPromise = null;
-      throw err;
-    });
-  }
-  return extractorPromise;
-}
-var LocalEmbeddingProvider = class {
-  id = "local";
-  model;
-  dimensions;
-  constructor(config) {
-    this.model = config.model || "Xenova/all-MiniLM-L6-v2";
-    this.dimensions = 384;
-  }
-  async embedQuery(text) {
-    const extractor = await getExtractor(this.model);
-    const output = await extractor(text, { pooling: "mean", normalize: true });
-    return Array.from(output.data);
-  }
-  async embedBatch(texts) {
-    if (texts.length === 0) return [];
-    const extractor = await getExtractor(this.model);
-    const output = await extractor(texts, { pooling: "mean", normalize: true });
-    const data = output.data;
-    const dims = this.dimensions;
-    const results = [];
-    for (let i = 0; i < texts.length; i++) {
-      results.push(Array.from(data.slice(i * dims, (i + 1) * dims)));
-    }
-    return results;
-  }
-};
-
-// src/memory/embeddings/cached.ts
-var CachedEmbeddingProvider = class {
-  constructor(inner, db) {
-    this.inner = inner;
-    this.db = db;
-    this.id = inner.id;
-    this.model = inner.model;
-    this.dimensions = inner.dimensions;
-  }
-  id;
-  model;
-  dimensions;
-  hits = 0;
-  misses = 0;
-  ops = 0;
-  cacheGet(hash) {
-    return this.db.prepare(
-      `SELECT embedding FROM embedding_cache WHERE hash = ? AND model = ? AND provider = ?`
-    ).get(hash, this.model, this.id);
-  }
-  cachePut(hash, blob) {
-    this.db.prepare(
-      `INSERT OR REPLACE INTO embedding_cache (hash, embedding, model, provider, dims, created_at, accessed_at)
-         VALUES (?, ?, ?, ?, ?, unixepoch(), unixepoch())`
-    ).run(hash, blob, this.model, this.id, this.dimensions);
-  }
-  cacheTouch(hash) {
-    this.db.prepare(
-      `UPDATE embedding_cache SET accessed_at = unixepoch() WHERE hash = ? AND model = ? AND provider = ?`
-    ).run(hash, this.model, this.id);
-  }
-  async embedQuery(text) {
-    const hash = hashText(text);
-    const row = this.cacheGet(hash);
-    if (row) {
-      this.hits++;
-      this.cacheTouch(hash);
-      this.tick();
-      return deserializeEmbedding(row.embedding);
-    }
-    this.misses++;
-    const embedding = await this.inner.embedQuery(text);
-    this.cachePut(hash, serializeEmbedding(embedding));
-    this.tick();
-    return embedding;
-  }
-  async embedBatch(texts) {
-    if (texts.length === 0) return [];
-    const hashes = texts.map(hashText);
-    const results = new Array(texts.length).fill(null);
-    const missIndices = [];
-    const missTexts = [];
-    for (let i = 0; i < texts.length; i++) {
-      const row = this.cacheGet(hashes[i]);
-      if (row) {
-        this.hits++;
-        this.cacheTouch(hashes[i]);
-        results[i] = deserializeEmbedding(row.embedding);
-      } else {
-        this.misses++;
-        missIndices.push(i);
-        missTexts.push(texts[i]);
-      }
-    }
-    if (missTexts.length > 0) {
-      const newEmbeddings = await this.inner.embedBatch(missTexts);
-      for (let j = 0; j < missIndices.length; j++) {
-        const idx = missIndices[j];
-        const embedding = newEmbeddings[j] ?? [];
-        results[idx] = embedding;
-        if (embedding.length > 0) {
-          this.cachePut(hashes[idx], serializeEmbedding(embedding));
-        }
-      }
-    }
-    this.ops += texts.length;
-    this.maybeEvict();
-    this.maybeLogStats();
-    return results;
-  }
-  tick() {
-    this.ops++;
-    this.maybeEvict();
-    this.maybeLogStats();
-  }
-  maybeLogStats() {
-    const total = this.hits + this.misses;
-    if (total > 0 && total % 100 === 0) {
-      const rate = (this.hits / total * 100).toFixed(0);
-      console.log(
-        `\u{1F4CA} Embedding cache: ${this.hits} hits, ${this.misses} misses (${rate}% hit rate)`
-      );
-    }
-  }
-  maybeEvict() {
-    if (this.ops % EMBEDDING_CACHE_EVICTION_INTERVAL !== 0) return;
-    try {
-      const cutoff = Math.floor(Date.now() / 1e3) - EMBEDDING_CACHE_TTL_DAYS * 86400;
-      this.db.prepare(`DELETE FROM embedding_cache WHERE accessed_at < ?`).run(cutoff);
-      const count = this.db.prepare(`SELECT COUNT(*) as cnt FROM embedding_cache`).get().cnt;
-      if (count > EMBEDDING_CACHE_MAX_ENTRIES) {
-        const toDelete = Math.ceil(count * EMBEDDING_CACHE_EVICTION_RATIO);
-        this.db.prepare(
-          `DELETE FROM embedding_cache WHERE (hash, model, provider) IN (
-              SELECT hash, model, provider FROM embedding_cache ORDER BY accessed_at ASC LIMIT ?
-            )`
-        ).run(toDelete);
-        console.log(`\u{1F9F9} Embedding cache eviction: removed ${toDelete} entries (${count} total)`);
-      }
-    } catch (err) {
-      console.warn("\u26A0\uFE0F Embedding cache eviction error:", err);
-    }
-  }
-};
-
-// src/memory/embeddings/index.ts
-function createEmbeddingProvider(config) {
-  switch (config.provider) {
-    case "anthropic":
-      if (!config.apiKey) {
-        throw new Error("API key required for Anthropic embedding provider");
-      }
-      return new AnthropicEmbeddingProvider({
-        apiKey: config.apiKey,
-        model: config.model
-      });
-    case "local":
-      return new LocalEmbeddingProvider({
-        model: config.model
-      });
-    case "none":
-      return new NoopEmbeddingProvider();
-    default:
-      throw new Error(`Unknown embedding provider: ${config.provider}`);
-  }
-}
-function hashText(text) {
-  return createHash("sha256").update(text).digest("hex");
-}
-function serializeEmbedding(embedding) {
-  return Buffer.from(new Float32Array(embedding).buffer);
-}
-function deserializeEmbedding(data) {
-  try {
-    if (Buffer.isBuffer(data)) {
-      const floats = new Float32Array(data.buffer, data.byteOffset, data.byteLength / 4);
-      return Array.from(floats);
-    }
-    return JSON.parse(data);
-  } catch {
-    return [];
-  }
-}
-
 // src/memory/agent/knowledge.ts
-import { readFileSync, existsSync as existsSync3, readdirSync, statSync } from "fs";
-import { join as join2 } from "path";
+import { readFileSync, existsSync as existsSync2, readdirSync, statSync } from "fs";
+import { join } from "path";
 var KnowledgeIndexer = class {
   constructor(db, workspaceDir, embedder, vectorEnabled) {
     this.db = db;
@@ -1098,7 +688,7 @@ var KnowledgeIndexer = class {
     return { indexed, skipped };
   }
   async indexFile(absPath) {
-    if (!existsSync3(absPath) || !absPath.endsWith(".md")) {
+    if (!existsSync2(absPath) || !absPath.endsWith(".md")) {
       return false;
     }
     const content = readFileSync(absPath, "utf-8");
@@ -1146,15 +736,15 @@ var KnowledgeIndexer = class {
   }
   listMemoryFiles() {
     const files = [];
-    const memoryMd = join2(this.workspaceDir, "MEMORY.md");
-    if (existsSync3(memoryMd)) {
+    const memoryMd = join(this.workspaceDir, "MEMORY.md");
+    if (existsSync2(memoryMd)) {
       files.push(memoryMd);
     }
-    const memoryDir = join2(this.workspaceDir, "memory");
-    if (existsSync3(memoryDir)) {
+    const memoryDir = join(this.workspaceDir, "memory");
+    if (existsSync2(memoryDir)) {
       const entries = readdirSync(memoryDir);
       for (const entry of entries) {
-        const absPath = join2(memoryDir, entry);
+        const absPath = join(memoryDir, entry);
         if (statSync(absPath).isFile() && entry.endsWith(".md")) {
           files.push(absPath);
         }
@@ -1978,11 +1568,6 @@ function initializeMemory(config) {
 }
 
 export {
-  JOURNAL_SCHEMA,
-  USED_TRANSACTIONS_SCHEMA,
-  openModuleDb,
-  createDbWrapper,
-  migrateFromMainDb,
   ensureSchema,
   ensureVectorTables,
   getSchemaVersion,
@@ -1992,22 +1577,6 @@ export {
   MemoryDatabase,
   getDatabase,
   closeDatabase,
-  NoopEmbeddingProvider,
-  fetchWithTimeout,
-  setTonapiKey,
-  tonapiFetch,
-  STONFI_API_BASE_URL,
-  GECKOTERMINAL_API_URL,
-  COINGECKO_API_URL,
-  OPENAI_TTS_URL,
-  ELEVENLABS_TTS_URL,
-  AnthropicEmbeddingProvider,
-  LocalEmbeddingProvider,
-  CachedEmbeddingProvider,
-  createEmbeddingProvider,
-  hashText,
-  serializeEmbedding,
-  deserializeEmbedding,
   KnowledgeIndexer,
   SessionStore,
   MessageStore,