trellis 1.0.8 → 2.0.6

package/dist/index-cy9k1g6v.js

@@ -0,0 +1,684 @@
+// @bun
+import {
+  __esm,
+  __export,
+  __require
+} from "./index-a76rekgs.js";
+
+// src/embeddings/types.ts
+var DEFAULT_MODEL_CONFIG;
+var init_types = __esm(() => {
+  DEFAULT_MODEL_CONFIG = {
+    modelName: "Xenova/all-MiniLM-L6-v2",
+    dimension: 384
+  };
+});
+
+// src/embeddings/model.ts
+async function loadModel(config = DEFAULT_MODEL_CONFIG) {
+  if (pipeline)
+    return pipeline;
+  if (!loadPromise) {
+    loadPromise = (async () => {
+      const { pipeline: createPipeline } = await import("./transformers-m9je15kg.js");
+      const opts = {};
+      if (config.cacheDir) {
+        opts.cache_dir = config.cacheDir;
+      }
+      pipeline = await createPipeline("feature-extraction", config.modelName, opts);
+      return pipeline;
+    })();
+  }
+  return loadPromise;
+}
+async function embed(text, config = DEFAULT_MODEL_CONFIG) {
+  const pipe = await loadModel(config);
+  const output = await pipe(text, { pooling: "mean", normalize: true });
+  return new Float32Array(output.data);
+}
+async function embedBatch(texts, config = DEFAULT_MODEL_CONFIG) {
+  if (texts.length === 0)
+    return [];
+  const pipe = await loadModel(config);
+  const results = [];
+  const batchSize = 32;
+  for (let i = 0;i < texts.length; i += batchSize) {
+    const batch = texts.slice(i, i + batchSize);
+    for (const text of batch) {
+      const output = await pipe(text, { pooling: "mean", normalize: true });
+      results.push(new Float32Array(output.data));
+    }
+  }
+  return results;
+}
+function resetModel() {
+  pipeline = null;
+  loadPromise = null;
+}
+var pipeline = null, loadPromise = null;
+var init_model = __esm(() => {
+  init_types();
+});
+
+// src/embeddings/store.ts
+import { Database } from "bun:sqlite";
+
+class VectorStore {
+  db;
+  constructor(dbPath) {
+    this.db = new Database(dbPath);
+    this.db.exec("PRAGMA journal_mode=WAL;");
+    this.db.exec("PRAGMA foreign_keys=ON;");
+    this.db.exec(SCHEMA_SQL);
+  }
+  upsert(record) {
+    const insertChunk = this.db.prepare(`
+      INSERT OR REPLACE INTO chunks (id, entity_id, content, chunk_type, file_path, updated_at)
+      VALUES ($id, $entityId, $content, $chunkType, $filePath, $updatedAt)
+    `);
+    const insertVector = this.db.prepare(`
+      INSERT OR REPLACE INTO vectors (id, embedding)
+      VALUES ($id, $embedding)
+    `);
+    const embeddingBlob = Buffer.from(record.embedding.buffer);
+    this.db.transaction(() => {
+      insertChunk.run({
+        $id: record.id,
+        $entityId: record.entityId,
+        $content: record.content,
+        $chunkType: record.chunkType,
+        $filePath: record.filePath ?? null,
+        $updatedAt: record.updatedAt
+      });
+      insertVector.run({
+        $id: record.id,
+        $embedding: embeddingBlob
+      });
+    })();
+  }
+  upsertBatch(records) {
+    if (records.length === 0)
+      return;
+    const insertChunk = this.db.prepare(`
+      INSERT OR REPLACE INTO chunks (id, entity_id, content, chunk_type, file_path, updated_at)
+      VALUES ($id, $entityId, $content, $chunkType, $filePath, $updatedAt)
+    `);
+    const insertVector = this.db.prepare(`
+      INSERT OR REPLACE INTO vectors (id, embedding)
+      VALUES ($id, $embedding)
+    `);
+    this.db.transaction(() => {
+      for (const record of records) {
+        const embeddingBlob = Buffer.from(record.embedding.buffer);
+        insertChunk.run({
+          $id: record.id,
+          $entityId: record.entityId,
+          $content: record.content,
+          $chunkType: record.chunkType,
+          $filePath: record.filePath ?? null,
+          $updatedAt: record.updatedAt
+        });
+        insertVector.run({
+          $id: record.id,
+          $embedding: embeddingBlob
+        });
+      }
+    })();
+  }
+  delete(id) {
+    this.db.prepare("DELETE FROM vectors WHERE id = ?").run(id);
+    this.db.prepare("DELETE FROM chunks WHERE id = ?").run(id);
+  }
+  deleteByEntity(entityId) {
+    const ids = this.db.prepare("SELECT id FROM chunks WHERE entity_id = ?").all(entityId);
+    if (ids.length === 0)
+      return;
+    this.db.transaction(() => {
+      for (const { id } of ids) {
+        this.db.prepare("DELETE FROM vectors WHERE id = ?").run(id);
+        this.db.prepare("DELETE FROM chunks WHERE id = ?").run(id);
+      }
+    })();
+  }
+  deleteByFile(filePath) {
+    const ids = this.db.prepare("SELECT id FROM chunks WHERE file_path = ?").all(filePath);
+    if (ids.length === 0)
+      return;
+    this.db.transaction(() => {
+      for (const { id } of ids) {
+        this.db.prepare("DELETE FROM vectors WHERE id = ?").run(id);
+        this.db.prepare("DELETE FROM chunks WHERE id = ?").run(id);
+      }
+    })();
+  }
+  getChunk(id) {
+    const row = this.db.prepare("SELECT * FROM chunks WHERE id = ?").get(id);
+    if (!row)
+      return null;
+    return rowToChunkMeta(row);
+  }
+  search(queryVector, opts = {}) {
+    const limit = opts.limit ?? 10;
+    const minScore = opts.minScore ?? 0;
+    const conditions = [];
+    const params = {};
+    if (opts.types && opts.types.length > 0) {
+      const placeholders = opts.types.map((_, i) => `$type${i}`).join(", ");
+      conditions.push(`c.chunk_type IN (${placeholders})`);
+      opts.types.forEach((t, i) => {
+        params[`$type${i}`] = t;
+      });
+    }
+    if (opts.filePrefix) {
+      conditions.push("c.file_path LIKE $filePrefix");
+      params.$filePrefix = `${opts.filePrefix}%`;
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const sql = `
+      SELECT c.id, c.entity_id, c.content, c.chunk_type, c.file_path, c.updated_at,
+             v.embedding
+      FROM chunks c
+      JOIN vectors v ON c.id = v.id
+      ${where}
+    `;
+    const rows = this.db.prepare(sql).all(params);
+    const scored = [];
+    for (const row of rows) {
+      const storedVec = new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / 4);
+      const score = cosineSimilarity(queryVector, storedVec);
+      if (score >= minScore) {
+        scored.push({
+          chunk: rowToChunkMeta(row),
+          score
+        });
+      }
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, limit);
+  }
+  count() {
+    const row = this.db.prepare("SELECT COUNT(*) as cnt FROM chunks").get();
+    return row?.cnt ?? 0;
+  }
+  countByType() {
+    const rows = this.db.prepare("SELECT chunk_type, COUNT(*) as cnt FROM chunks GROUP BY chunk_type").all();
+    const result = {};
+    for (const row of rows) {
+      result[row.chunk_type] = row.cnt;
+    }
+    return result;
+  }
+  clear() {
+    this.db.exec("DELETE FROM vectors");
+    this.db.exec("DELETE FROM chunks");
+  }
+  close() {
+    this.db.close();
+  }
+}
+function rowToChunkMeta(row) {
+  return {
+    id: row.id,
+    entityId: row.entity_id,
+    content: row.content,
+    chunkType: row.chunk_type,
+    filePath: row.file_path ?? undefined,
+    updatedAt: row.updated_at
+  };
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length)
+    return 0;
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0;i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+var SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS chunks (
+  id TEXT PRIMARY KEY,
+  entity_id TEXT NOT NULL,
+  content TEXT NOT NULL,
+  chunk_type TEXT NOT NULL,
+  file_path TEXT,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS vectors (
+  id TEXT PRIMARY KEY,
+  embedding BLOB NOT NULL,
+  FOREIGN KEY (id) REFERENCES chunks(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_chunks_entity ON chunks(entity_id);
+CREATE INDEX IF NOT EXISTS idx_chunks_type ON chunks(chunk_type);
+CREATE INDEX IF NOT EXISTS idx_chunks_file ON chunks(file_path);
+`;
+var init_store = () => {};
+
+// src/embeddings/chunker.ts
+function chunkIssue(issue) {
+  const now = new Date().toISOString();
+  const chunks = [];
+  if (issue.title) {
+    chunks.push({
+      id: `issue:${issue.id}:title`,
+      entityId: `issue:${issue.id}`,
+      content: issue.title,
+      chunkType: "issue_title",
+      updatedAt: now
+    });
+  }
+  if (issue.description) {
+    chunks.push({
+      id: `issue:${issue.id}:desc`,
+      entityId: `issue:${issue.id}`,
+      content: issue.description,
+      chunkType: "issue_desc",
+      updatedAt: now
+    });
+  }
+  return chunks;
+}
+function chunkDecision(decision) {
+  const parts = [];
+  parts.push(`Decision ${decision.id}: ${decision.toolName}`);
+  if (decision.rationale)
+    parts.push(`Rationale: ${decision.rationale}`);
+  if (decision.context)
+    parts.push(`Context: ${decision.context}`);
+  if (decision.outputSummary)
+    parts.push(`Output: ${decision.outputSummary}`);
+  const content = parts.join(`
+`);
+  if (!content.trim())
+    return [];
+  return [
+    {
+      id: `decision:${decision.id}:rationale`,
+      entityId: `decision:${decision.id}`,
+      content,
+      chunkType: "decision_rationale",
+      updatedAt: new Date().toISOString()
+    }
+  ];
+}
+function chunkMilestone(milestone) {
+  if (!milestone.message)
+    return [];
+  return [
+    {
+      id: `milestone:${milestone.id}:msg`,
+      entityId: `milestone:${milestone.id}`,
+      content: milestone.message,
+      chunkType: "milestone_msg",
+      updatedAt: new Date().toISOString()
+    }
+  ];
+}
+function chunkMarkdown(filePath, content) {
+  if (!content.trim())
+    return [];
+  const entityId = `file:${filePath}`;
+  const now = new Date().toISOString();
+  const sections = splitByHeadings(content);
+  const chunks = [];
+  for (let i = 0;i < sections.length; i++) {
+    const section = sections[i];
+    if (!section.text.trim())
+      continue;
+    if (section.text.length <= MAX_CHUNK_CHARS) {
+      chunks.push({
+        id: `${entityId}:section:${i}`,
+        entityId,
+        content: section.text,
+        chunkType: "markdown",
+        filePath,
+        updatedAt: now
+      });
+    } else {
+      const windows = slidingWindow(section.text);
+      for (let w = 0;w < windows.length; w++) {
+        chunks.push({
+          id: `${entityId}:section:${i}:w${w}`,
+          entityId,
+          content: windows[w],
+          chunkType: "markdown",
+          filePath,
+          updatedAt: now
+        });
+      }
+    }
+  }
+  return chunks;
+}
+function chunkCodeEntities(filePath, declarations) {
+  const now = new Date().toISOString();
+  const chunks = [];
+  for (const decl of declarations) {
+    const parts = [];
+    if (decl.docComment)
+      parts.push(decl.docComment);
+    parts.push(`${decl.kind} ${decl.name}`);
+    parts.push(decl.signature);
+    const content = parts.join(`
+`).slice(0, MAX_CHUNK_CHARS);
+    chunks.push({
+      id: `symbol:${filePath}#${decl.name}`,
+      entityId: `symbol:${filePath}#${decl.name}`,
+      content,
+      chunkType: "code_entity",
+      filePath,
+      updatedAt: now
+    });
+  }
+  return chunks;
+}
+function chunkDocComments(filePath, comments) {
+  if (comments.length === 0)
+    return [];
+  const entityId = `file:${filePath}`;
+  const now = new Date().toISOString();
+  const chunks = [];
+  for (let i = 0;i < comments.length; i++) {
+    const comment = comments[i];
+    if (!comment.text.trim())
+      continue;
+    chunks.push({
+      id: `${entityId}:doc:${i}`,
+      entityId,
+      content: comment.text.slice(0, MAX_CHUNK_CHARS),
+      chunkType: "doc_comment",
+      filePath,
+      updatedAt: now
+    });
+  }
+  return chunks;
+}
+function chunkSummary(filePath, content) {
+  if (!content.trim())
+    return [];
+  const entityId = `file:${filePath}`;
+  const now = new Date().toISOString();
+  if (content.length <= MAX_CHUNK_CHARS) {
+    return [
+      {
+        id: `${entityId}:summary`,
+        entityId,
+        content,
+        chunkType: "summary_md",
+        filePath,
+        updatedAt: now
+      }
+    ];
+  }
+  return chunkMarkdown(filePath, content).map((c) => ({
+    ...c,
+    chunkType: "summary_md"
+  }));
+}
+function chunkFile(filePath, content) {
+  if (!content.trim())
+    return [];
+  const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
+  if (filePath.endsWith("summary.md")) {
+    return chunkSummary(filePath, content);
+  }
+  if (ext === "md") {
+    return chunkMarkdown(filePath, content);
+  }
+  return [];
+}
+function splitByHeadings(content) {
+  const lines = content.split(`
+`);
+  const sections = [];
+  let currentSection = { text: "" };
+  for (const line of lines) {
+    if (/^#{1,3}\s/.test(line)) {
+      if (currentSection.text.trim()) {
+        sections.push(currentSection);
+      }
+      currentSection = { heading: line, text: line + `
+` };
+    } else {
+      currentSection.text += line + `
+`;
+    }
+  }
+  if (currentSection.text.trim()) {
+    sections.push(currentSection);
+  }
+  return sections;
+}
+function slidingWindow(text) {
+  const windows = [];
+  let start = 0;
+  while (start < text.length) {
+    const end = Math.min(start + MAX_CHUNK_CHARS, text.length);
+    windows.push(text.slice(start, end));
+    if (end >= text.length)
+      break;
+    start += MAX_CHUNK_CHARS - OVERLAP_CHARS;
+  }
+  return windows;
+}
+var MAX_CHUNK_CHARS = 512, OVERLAP_CHARS = 64;
+var init_chunker = () => {};
+
+// src/embeddings/search.ts
+import { join } from "path";
+import { readFileSync, existsSync } from "fs";
+
+class EmbeddingManager {
+  store;
+  embedFn;
+  constructor(dbPath, embedFn) {
+    this.store = new VectorStore(dbPath);
+    this.embedFn = embedFn ?? embed;
+  }
+  async reindex(engine) {
+    this.store.clear();
+    const allChunks = [];
+    const issues = engine.listIssues();
+    for (const issue of issues) {
+      allChunks.push(...chunkIssue(issue));
+    }
+    const milestones = engine.listMilestones();
+    for (const ms of milestones) {
+      allChunks.push(...chunkMilestone(ms));
+    }
+    if (engine.queryDecisions) {
+      const decisions = engine.queryDecisions();
+      for (const dec of decisions) {
+        allChunks.push(...chunkDecision(dec));
+      }
+    }
+    const rootPath = engine.getRootPath();
+    const trackedFiles = engine.trackedFiles();
+    for (const tf of trackedFiles) {
+      try {
+        const absPath = join(rootPath, tf.path);
+        if (!existsSync(absPath))
+          continue;
+        const content = readFileSync(absPath, "utf-8");
+        allChunks.push(...chunkFile(tf.path, content));
+      } catch {}
+    }
+    if (engine.parseFile) {
+      for (const tf of trackedFiles) {
+        const ext = tf.path.split(".").pop()?.toLowerCase() ?? "";
+        if (![
+          "ts",
+          "js",
+          "tsx",
+          "jsx",
+          "py",
+          "go",
+          "rs",
+          "rb",
+          "java",
+          "cs"
+        ].includes(ext)) {
+          continue;
+        }
+        try {
+          const parsed = engine.parseFile(tf.path);
+          if (parsed && Array.isArray(parsed.entities)) {
+            const declarations = parsed.entities.map((e) => ({
+              id: e.id ?? e.name,
+              name: e.name,
+              kind: e.kind,
+              signature: e.signature ?? e.rawText?.split(`
+`)[0] ?? "",
+              docComment: e.docComment
+            }));
+            allChunks.push(...chunkCodeEntities(tf.path, declarations));
+          }
+        } catch {}
+      }
+    }
+    const records = [];
+    for (const chunk of allChunks) {
+      try {
+        const vector = await this.embedFn(chunk.content);
+        records.push({ ...chunk, embedding: vector });
+      } catch {}
+    }
+    this.store.upsertBatch(records);
+    return { chunks: records.length };
+  }
+  async indexFile(filePath, content, engine) {
+    this.store.deleteByFile(filePath);
+    const chunks = chunkFile(filePath, content);
+    if (engine?.parseFile) {
+      const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
+      if ([
+        "ts",
+        "js",
+        "tsx",
+        "jsx",
+        "py",
+        "go",
+        "rs",
+        "rb",
+        "java",
+        "cs"
+      ].includes(ext)) {
+        try {
+          const parsed = engine.parseFile(filePath);
+          if (parsed && Array.isArray(parsed.entities)) {
+            const declarations = parsed.entities.map((e) => ({
+              id: e.id ?? e.name,
+              name: e.name,
+              kind: e.kind,
+              signature: e.signature ?? e.rawText?.split(`
+`)[0] ?? "",
+              docComment: e.docComment
+            }));
+            chunks.push(...chunkCodeEntities(filePath, declarations));
+          }
+        } catch {}
+      }
+    }
+    const records = [];
+    for (const chunk of chunks) {
+      try {
+        const vector = await this.embedFn(chunk.content);
+        records.push({ ...chunk, embedding: vector });
+      } catch {}
+    }
+    if (records.length > 0) {
+      this.store.upsertBatch(records);
+    }
+    return records.length;
+  }
+  async indexIssue(issue) {
+    this.store.deleteByEntity(`issue:${issue.id}`);
+    const chunks = chunkIssue(issue);
+    const records = [];
+    for (const chunk of chunks) {
+      try {
+        const vector = await this.embedFn(chunk.content);
+        records.push({ ...chunk, embedding: vector });
+      } catch {}
+    }
+    if (records.length > 0) {
+      this.store.upsertBatch(records);
+    }
+    return records.length;
+  }
+  async indexMilestone(milestone) {
+    this.store.deleteByEntity(`milestone:${milestone.id}`);
+    const chunks = chunkMilestone(milestone);
+    const records = [];
+    for (const chunk of chunks) {
+      try {
+        const vector = await this.embedFn(chunk.content);
+        records.push({ ...chunk, embedding: vector });
+      } catch {}
+    }
+    if (records.length > 0) {
+      this.store.upsertBatch(records);
+    }
+    return records.length;
+  }
+  async search(query, opts) {
+    const queryVector = await this.embedFn(query);
+    return this.store.search(queryVector, opts);
+  }
+  removeFile(filePath) {
+    this.store.deleteByFile(filePath);
+  }
+  stats() {
+    return {
+      total: this.store.count(),
+      byType: this.store.countByType()
+    };
+  }
+  close() {
+    this.store.close();
+  }
+}
+var init_search = __esm(() => {
+  init_store();
+  init_model();
+  init_chunker();
+});
+
+// src/embeddings/index.ts
+var exports_embeddings = {};
+__export(exports_embeddings, {
+  slidingWindow: () => slidingWindow,
+  resetModel: () => resetModel,
+  loadModel: () => loadModel,
+  embedBatch: () => embedBatch,
+  embed: () => embed,
+  cosineSimilarity: () => cosineSimilarity,
+  chunkSummary: () => chunkSummary,
+  chunkMilestone: () => chunkMilestone,
+  chunkMarkdown: () => chunkMarkdown,
+  chunkIssue: () => chunkIssue,
+  chunkFile: () => chunkFile,
+  chunkDocComments: () => chunkDocComments,
+  chunkDecision: () => chunkDecision,
+  chunkCodeEntities: () => chunkCodeEntities,
+  VectorStore: () => VectorStore,
+  EmbeddingManager: () => EmbeddingManager,
+  DEFAULT_MODEL_CONFIG: () => DEFAULT_MODEL_CONFIG
+});
+var init_embeddings = __esm(() => {
+  init_types();
+  init_model();
+  init_store();
+  init_search();
+  init_chunker();
+});
+
+export { DEFAULT_MODEL_CONFIG, loadModel, embed, embedBatch, resetModel, VectorStore, cosineSimilarity, chunkIssue, chunkDecision, chunkMilestone, chunkMarkdown, chunkCodeEntities, chunkDocComments, chunkSummary, chunkFile, slidingWindow, EmbeddingManager, exports_embeddings, init_embeddings };