teleton 0.5.2 → 0.6.0

package/dist/{task-dependency-resolver-TRPILAHM.js → task-dependency-resolver-72DLY2HV.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-4DU3C27M.js";
 import {
   MAX_DEPENDENTS_PER_TASK
-} from "./chunk-O4R7V5Y2.js";
+} from "./chunk-RO62LO6Z.js";
 import "./chunk-QGM4M3NI.js";
 
 // src/telegram/task-dependency-resolver.ts

package/dist/{task-executor-N7XNVK5N.js → task-executor-VXB6DAV2.js}

@@ -3,7 +3,7 @@ import {
   MAX_TOTAL_PROMPT_CHARS,
   SECONDS_PER_DAY,
   SECONDS_PER_HOUR
-} from "./chunk-O4R7V5Y2.js";
+} from "./chunk-RO62LO6Z.js";
 import "./chunk-QGM4M3NI.js";
 
 // src/telegram/task-executor.ts

package/dist/tool-index-DKI2ZNOU.js

@@ -0,0 +1,245 @@
+import {
+  serializeEmbedding
+} from "./chunk-D5I7GBV7.js";
+import "./chunk-GDCODBNO.js";
+import "./chunk-4DU3C27M.js";
+import {
+  TOOL_RAG_KEYWORD_WEIGHT,
+  TOOL_RAG_MIN_SCORE,
+  TOOL_RAG_VECTOR_WEIGHT
+} from "./chunk-RO62LO6Z.js";
+import "./chunk-EYWNOHMJ.js";
+import "./chunk-QGM4M3NI.js";
+
+// src/agent/tools/tool-index.ts
+function escapeFts5Query(query) {
+  return query.replace(/["\*\-\+\(\)\:\^\~\?\.\@\#\$\%\&\!\[\]\{\}\|\\\/<>=,;'`]/g, " ").replace(/\s+/g, " ").trim();
+}
+function bm25ToScore(rank) {
+  return 1 / (1 + Math.exp(rank));
+}
+var ToolIndex = class {
+  constructor(db, embedder, vectorEnabled, config) {
+    this.db = db;
+    this.embedder = embedder;
+    this.vectorEnabled = vectorEnabled;
+    this.config = config;
+  }
+  _isIndexed = false;
+  get isIndexed() {
+    return this._isIndexed;
+  }
+  /**
+   * Create the vector table (dimensions are dynamic, so can't be in schema migration).
+   */
+  ensureSchema() {
+    if (!this.vectorEnabled || this.embedder.dimensions === 0) return;
+    try {
+      const existing = this.db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='tool_index_vec'`).get();
+      if (existing?.sql && !existing.sql.includes(`[${this.embedder.dimensions}]`)) {
+        this.db.exec(`DROP TABLE IF EXISTS tool_index_vec`);
+      }
+      this.db.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS tool_index_vec USING vec0(
+          name TEXT PRIMARY KEY,
+          embedding FLOAT[${this.embedder.dimensions}] distance_metric=cosine
+        );
+      `);
+    } catch (error) {
+      console.error("[tool-rag] Failed to create vector table:", error);
+      this.vectorEnabled = false;
+    }
+  }
+  /**
+   * Index all registered tools. Replaces any previous index.
+   */
+  async indexAll(tools) {
+    try {
+      this.db.exec(`DELETE FROM tool_index`);
+      if (this.vectorEnabled) {
+        try {
+          this.db.exec(`DELETE FROM tool_index_vec`);
+        } catch {
+        }
+      }
+      const entries = tools.map((t) => ({
+        name: t.name,
+        description: t.description ?? "",
+        searchText: `${t.name} \u2014 ${t.description ?? ""}`
+      }));
+      const embeddings = [];
+      if (this.vectorEnabled && this.embedder.dimensions > 0) {
+        const texts = entries.map((e) => e.searchText);
+        const batchSize = 128;
+        for (let i = 0; i < texts.length; i += batchSize) {
+          const batch = texts.slice(i, i + batchSize);
+          const batchEmbeddings = await this.embedder.embedBatch(batch);
+          embeddings.push(...batchEmbeddings);
+        }
+      }
+      const insertTool = this.db.prepare(`
+        INSERT INTO tool_index (name, description, search_text, updated_at)
+        VALUES (?, ?, ?, unixepoch())
+      `);
+      const insertVec = this.vectorEnabled ? this.db.prepare(`INSERT INTO tool_index_vec (name, embedding) VALUES (?, ?)`) : null;
+      const txn = this.db.transaction(() => {
+        for (let i = 0; i < entries.length; i++) {
+          const e = entries[i];
+          insertTool.run(e.name, e.description, e.searchText);
+          if (insertVec && embeddings[i]?.length > 0) {
+            insertVec.run(e.name, serializeEmbedding(embeddings[i]));
+          }
+        }
+      });
+      txn();
+      this._isIndexed = true;
+      return entries.length;
+    } catch (error) {
+      console.error("[tool-rag] Indexing failed:", error);
+      this._isIndexed = false;
+      return 0;
+    }
+  }
+  /**
+   * Delta update for hot-reload plugins.
+   */
+  async reindexTools(removed, added) {
+    try {
+      if (removed.length > 0) {
+        const deleteTool = this.db.prepare(`DELETE FROM tool_index WHERE name = ?`);
+        const deleteVec = this.vectorEnabled ? this.db.prepare(`DELETE FROM tool_index_vec WHERE name = ?`) : null;
+        for (const name of removed) {
+          deleteTool.run(name);
+          deleteVec?.run(name);
+        }
+      }
+      if (added.length > 0) {
+        const entries = added.map((t) => ({
+          name: t.name,
+          description: t.description ?? "",
+          searchText: `${t.name} \u2014 ${t.description ?? ""}`
+        }));
+        let embeddings = [];
+        if (this.vectorEnabled && this.embedder.dimensions > 0) {
+          embeddings = await this.embedder.embedBatch(entries.map((e) => e.searchText));
+        }
+        const insertTool = this.db.prepare(`
+          INSERT OR REPLACE INTO tool_index (name, description, search_text, updated_at)
+          VALUES (?, ?, ?, unixepoch())
+        `);
+        const deleteVec = this.vectorEnabled ? this.db.prepare(`DELETE FROM tool_index_vec WHERE name = ?`) : null;
+        const insertVec = this.vectorEnabled ? this.db.prepare(`INSERT INTO tool_index_vec (name, embedding) VALUES (?, ?)`) : null;
+        const txn = this.db.transaction(() => {
+          for (let i = 0; i < entries.length; i++) {
+            const e = entries[i];
+            insertTool.run(e.name, e.description, e.searchText);
+            if (insertVec && embeddings[i]?.length > 0) {
+              deleteVec.run(e.name);
+              insertVec.run(e.name, serializeEmbedding(embeddings[i]));
+            }
+          }
+        });
+        txn();
+      }
+      console.log(`[tool-rag] Delta reindex: -${removed.length} +${added.length} tools`);
+    } catch (error) {
+      console.error("[tool-rag] Delta reindex failed:", error);
+    }
+  }
+  /**
+   * Hybrid search: vector + FTS5, same pattern as HybridSearch.
+   */
+  async search(query, queryEmbedding, limit) {
+    const topK = limit ?? this.config.topK;
+    const vectorResults = this.vectorEnabled ? this.vectorSearch(queryEmbedding, topK * 3) : [];
+    const keywordResults = this.keywordSearch(query, topK * 3);
+    return this.mergeResults(vectorResults, keywordResults, topK);
+  }
+  /**
+   * Check if a tool name matches any always-include pattern.
+   */
+  isAlwaysIncluded(toolName) {
+    for (const pattern of this.config.alwaysInclude) {
+      if (pattern.endsWith("*")) {
+        const prefix = pattern.slice(0, -1);
+        if (toolName.startsWith(prefix)) return true;
+      } else if (toolName === pattern) {
+        return true;
+      }
+    }
+    return false;
+  }
+  vectorSearch(embedding, limit) {
+    if (!this.vectorEnabled || embedding.length === 0) return [];
+    try {
+      const embeddingBuffer = serializeEmbedding(embedding);
+      const rows = this.db.prepare(
+        `
+          SELECT tv.name, ti.description, tv.distance
+          FROM (
+            SELECT name, distance
+            FROM tool_index_vec
+            WHERE embedding MATCH ? AND k = ?
+          ) tv
+          JOIN tool_index ti ON ti.name = tv.name
+        `
+      ).all(embeddingBuffer, limit);
+      return rows.map((row) => ({
+        name: row.name,
+        description: row.description,
+        score: 1 - row.distance,
+        vectorScore: 1 - row.distance
+      }));
+    } catch (error) {
+      console.error("[tool-rag] Vector search error:", error);
+      return [];
+    }
+  }
+  keywordSearch(query, limit) {
+    const safeQuery = escapeFts5Query(query);
+    if (!safeQuery) return [];
+    try {
+      const rows = this.db.prepare(
+        `
+          SELECT ti.name, ti.description, rank as score
+          FROM tool_index_fts tf
+          JOIN tool_index ti ON ti.rowid = tf.rowid
+          WHERE tool_index_fts MATCH ?
+          ORDER BY rank
+          LIMIT ?
+        `
+      ).all(safeQuery, limit);
+      return rows.map((row) => ({
+        name: row.name,
+        description: row.description,
+        score: bm25ToScore(row.score),
+        keywordScore: bm25ToScore(row.score)
+      }));
+    } catch (error) {
+      console.error("[tool-rag] FTS5 search error:", error);
+      return [];
+    }
+  }
+  mergeResults(vectorResults, keywordResults, limit) {
+    const byName = /* @__PURE__ */ new Map();
+    for (const r of vectorResults) {
+      byName.set(r.name, { ...r, vectorScore: r.score });
+    }
+    for (const r of keywordResults) {
+      const existing = byName.get(r.name);
+      if (existing) {
+        existing.keywordScore = r.keywordScore;
+        existing.score = TOOL_RAG_VECTOR_WEIGHT * (existing.vectorScore ?? 0) + TOOL_RAG_KEYWORD_WEIGHT * (r.keywordScore ?? 0);
+      } else {
+        byName.set(r.name, {
+          ...r,
+          score: TOOL_RAG_KEYWORD_WEIGHT * (r.keywordScore ?? 0)
+        });
+      }
+    }
+    return Array.from(byName.values()).filter((r) => r.score >= TOOL_RAG_MIN_SCORE).sort((a, b) => b.score - a.score).slice(0, limit);
+  }
+};
+export {
+  ToolIndex
+};