agentcache 0.2.4 → 0.3.0

package/README.md

@@ -137,21 +137,15 @@ AgentCache prevents knowledge from growing unbounded:
 | IDE | MCP | Auto-Approve | Transcript Recovery | Hooks |
 |-----|-----|-------------|--------------------|----|
 | Claude Code | Yes | Yes (automatic) | Full (JSONL) | Stop, SessionStart, PreToolUse |
-| Cursor | Yes | **Manual** (see below) | Incremental only | — |
+| Cursor | Yes | Yes (automatic) | Incremental only | — |
 | Roo Code | Yes | Yes (automatic) | Incremental only | — |
 | Windsurf | Yes | Yes (automatic) | Incremental only | — |
 | Continue | Yes | Yes (automatic) | Full (JSON) | — |
 | Codex | Yes | Yes (automatic) | Incremental only | — |
 
-"Incremental only" means if the agent submits observations during the session, they're saved. If the session terminates before any submission, those observations are lost (no transcript access).
-
-### Cursor: Enable Auto-Approve
+All IDEs are fully auto-approved at install time — no manual steps required.
 
-Cursor does not support programmatic auto-approve for MCP tools. After installing, you need to manually enable it once:
-
-1. Open Cursor Settings → MCP
-2. Find **agentcache** in the server list
-3. Set tool approval to **"Always allow"** (or enable "Yolo mode" in Cursor settings for all tools)
+"Incremental only" means if the agent submits observations during the session, they're saved. If the session terminates before any submission, those observations are lost (no transcript access).
 
 ## Data Storage
 
@@ -191,6 +185,41 @@ Projects are identified by a hash of their full filesystem path, not just the fo
 - Renaming a folder creates a new project identity
 - Knowledge doesn't leak between same-named projects
 
+## Roadmap
+
+### More IDEs & Coding Agents
+
+| Platform | Status |
+|----------|--------|
+| Claude Code | Supported |
+| Cursor | Supported |
+| Roo Code | Supported |
+| Windsurf | Supported |
+| Continue | Supported |
+| Codex | Supported |
+| Goose (Block) | Coming soon |
+| Aider | Coming soon |
+| GitHub Copilot | Coming soon |
+| Zed AI | Coming soon |
+
+Any tool that supports MCP can use AgentCache today via `agentcache serve`. Native integrations for the above are planned to ensure zero-config setup.
+
+### Native Plugins
+
+Marketplace listings and deeper UI integrations for all supported IDEs — surfacing knowledge inline, showing compilation status, and providing one-click management of rules and decisions.
+
+### Team Knowledge Sharing
+
+Share compiled knowledge across your team. Rules and lessons that work for one developer benefit everyone.
+
+### Cloud Sync
+
+Sync your knowledge database across machines. Same developer, different computers, same knowledge.
+
+### Analytics Dashboard
+
+Visibility into what AgentCache is learning — compilation stats, knowledge growth, most-referenced rules, and session coverage.
+
 ## Contributing
 
 ```bash

package/dist/chunk-IER56P6A.js

@@ -0,0 +1,589 @@
+import {
+  getDataDir,
+  getGitContext
+} from "./chunk-WHP4Z32Z.js";
+
+// src/knowledge/passes/3-canonicalizer.ts
+import { createHash } from "crypto";
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "shall",
+  "can",
+  "need",
+  "must",
+  "to",
+  "of",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "as",
+  "into",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "this",
+  "that",
+  "these",
+  "those",
+  "it",
+  "its",
+  "and",
+  "but",
+  "or",
+  "nor",
+  "not",
+  "so",
+  "yet",
+  "all",
+  "each",
+  "every",
+  "both",
+  "few",
+  "more",
+  "most",
+  "i",
+  "we",
+  "you",
+  "they",
+  "he",
+  "she"
+]);
+var ANTONYM_MAP = [
+  [/\bnever\b/g, "forbidden"],
+  [/\bdon'?t\b/g, "forbidden"],
+  [/\bavoid\b/g, "forbidden"],
+  [/\bprohibit(ed)?\b/g, "forbidden"],
+  [/\balways\b/g, "required"],
+  [/\bmust\b/g, "required"],
+  [/\brequire(d)?\b/g, "required"],
+  [/\buse\b/g, "use"],
+  [/\bprefer\b/g, "use"]
+];
+function canonicalize(observations, existingCanonicalKeys) {
+  const canonicalized = observations.map((obs) => ({
+    ...obs,
+    canonicalKey: computeCanonicalKey(obs.content)
+  }));
+  const existingSet = new Set(existingCanonicalKeys || []);
+  const autoReinforced = [];
+  const needsClustering = [];
+  for (const obs of canonicalized) {
+    if (existingSet.has(obs.canonicalKey)) {
+      autoReinforced.push(obs);
+    } else {
+      needsClustering.push(obs);
+    }
+  }
+  return { observations: canonicalized, autoReinforced, needsClustering };
+}
+function computeCanonicalKey(content) {
+  let text = content.toLowerCase().trim();
+  for (const [pattern, replacement] of ANTONYM_MAP) {
+    text = text.replace(pattern, replacement);
+  }
+  text = text.replace(/[^\w\s]/g, " ");
+  const tokens = text.split(/\s+/).filter((t) => !STOP_WORDS.has(t) && t.length > 1).sort();
+  return tokens.join(" ");
+}
+function computeCanonicalHash(content) {
+  const key = computeCanonicalKey(content);
+  return createHash("sha256").update(key).digest("hex").slice(0, 16);
+}
+
+// src/knowledge/compiler.ts
+import { randomUUID as randomUUID3 } from "crypto";
+
+// src/knowledge/passes/1-extractor.ts
+import { randomUUID } from "crypto";
+var EXTRACT_PROMPT_VERSION = "extract-v1";
+function buildExtractionPrompt(events) {
+  const transcript = events.filter((e) => e.content || e.tool_name).map((e) => {
+    if (e.role) return `[${e.role}]: ${e.content}`;
+    if (e.tool_name) return `[tool:${e.tool_name}]: ${JSON.stringify(e.tool_input).slice(0, 500)}`;
+    return "";
+  }).filter(Boolean).join("\n");
+  return `You are a knowledge extraction engine. Analyze this coding session transcript and extract distinct learnings.
+
+Extract into four types:
+- rule: a standing instruction or constraint the developer expressed
+- lesson: a mistake made and what fixed it
+- decision: an architectural or design choice with rationale
+- context: current task state, open threads, what was left in progress
+
+Return ONLY valid JSON: { "observations": [{ "type": "rule"|"lesson"|"decision"|"context", "content": "...", "sourceQuote": "...", "confidence": "high"|"medium" }] }
+
+Only return high and medium confidence items. Ignore conversational noise, tool outputs, and implementation details that aren't generalizable.
+
+<transcript>
+${transcript}
+</transcript>`;
+}
+function parseExtractionResponse(text, sessionId, project) {
+  const jsonMatch = text.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) return [];
+  const parsed = JSON.parse(jsonMatch[0]);
+  if (!parsed.observations || !Array.isArray(parsed.observations)) return [];
+  const now = Date.now();
+  return parsed.observations.filter((o) => o.type && o.content && o.confidence).filter((o) => ["high", "medium"].includes(o.confidence)).map((o) => ({
+    id: `obs_${randomUUID().slice(0, 8)}`,
+    sessionId,
+    timestamp: now,
+    type: o.type,
+    content: o.content,
+    sourceQuote: o.sourceQuote || "",
+    confidence: o.confidence,
+    project,
+    scope: o.scope || (o.type === "rule" || o.type === "lesson" ? "global" : "project")
+  }));
+}
+
+// src/knowledge/passes/2-normalizer.ts
+var FILLER_PATTERNS = [
+  /^i (noticed|realized|learned|found|discovered|think) that /i,
+  /^it (seems|appears|looks) (like|that) /i,
+  /^we should /i,
+  /^you should /i,
+  /^basically,? /i,
+  /^essentially,? /i,
+  /^actually,? /i
+];
+var IMPERATIVE_RULES = [
+  [/^you should never /i, "Never "],
+  [/^we should never /i, "Never "],
+  [/^don't ever /i, "Never "],
+  [/^never /i, "Never "],
+  [/^you should always /i, "Always "],
+  [/^we should always /i, "Always "],
+  [/^always /i, "Always "]
+];
+function normalize(observations) {
+  const normalized = observations.map((obs) => ({
+    ...obs,
+    content: normalizeContent(obs.content, obs.type)
+  }));
+  const seen = /* @__PURE__ */ new Set();
+  return normalized.filter((obs) => {
+    const key = obs.content.toLowerCase().trim();
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function normalizeContent(content, type) {
+  let text = content.trim();
+  for (const pattern of FILLER_PATTERNS) {
+    text = text.replace(pattern, "");
+  }
+  if (type === "rule") {
+    for (const [pattern, replacement] of IMPERATIVE_RULES) {
+      if (pattern.test(text)) {
+        text = text.replace(pattern, replacement);
+        break;
+      }
+    }
+  }
+  text = text.charAt(0).toUpperCase() + text.slice(1);
+  const firstSentenceEnd = text.search(/\. [A-Z]/);
+  if (firstSentenceEnd > 0) {
+    text = text.slice(0, firstSentenceEnd + 1);
+  }
+  return text;
+}
+
+// src/knowledge/passes/4-clusterer.ts
+var CLUSTER_PROMPT_VERSION = "cluster-v1";
+function buildClusteringPrompt(observations, existingItems) {
+  const obsJson = observations.map((o) => ({
+    id: o.id,
+    type: o.type,
+    content: o.content,
+    canonicalKey: o.canonicalKey
+  }));
+  const itemsJson = existingItems.filter((i) => i.status === "active").map((i) => ({
+    id: i.id,
+    type: i.type,
+    content: i.content,
+    canonicalHash: i.canonicalHash
+  }));
+  return `You are a knowledge clustering engine. Determine whether new observations create new knowledge or relate to existing items. Be conservative.
+
+For each observation, assign an action:
+CREATE    \u2014 genuinely new knowledge, no existing item covers it
+REINFORCE \u2014 confirms an existing item (provide targetKnowledgeItemId)
+SUPERSEDE \u2014 replaces/corrects an existing item (provide targetKnowledgeItemId)
+DEPRECATE \u2014 makes an existing item irrelevant (provide targetKnowledgeItemId)
+IGNORE    \u2014 duplicate, trivial, or too vague to keep
+
+New observations:
+${JSON.stringify(obsJson, null, 2)}
+
+Existing knowledge items:
+${JSON.stringify(itemsJson, null, 2)}
+
+Return ONLY valid JSON: { "clusters": [{ "observationId": "...", "action": "CREATE"|"REINFORCE"|"SUPERSEDE"|"DEPRECATE"|"IGNORE", "targetKnowledgeItemId": "..." (only if action targets an existing item), "reasoning": "..." }] }`;
+}
+function parseClusteringResponse(text, observations) {
+  const jsonMatch = text.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    return observations.map((o) => ({ observationId: o.id, action: "CREATE", reasoning: "Parse failure \u2014 defaulting to CREATE" }));
+  }
+  const parsed = JSON.parse(jsonMatch[0]);
+  if (!parsed.clusters || !Array.isArray(parsed.clusters)) {
+    return observations.map((o) => ({ observationId: o.id, action: "CREATE", reasoning: "Parse failure \u2014 defaulting to CREATE" }));
+  }
+  return parsed.clusters.map((c) => ({
+    observationId: c.observationId,
+    action: c.action || "CREATE",
+    targetKnowledgeItemId: c.targetKnowledgeItemId || void 0,
+    reasoning: c.reasoning || ""
+  }));
+}
+
+// src/knowledge/passes/5-contradiction.ts
+var CONTRADICTION_PROMPT_VERSION = "contradiction-v1";
+
+// src/knowledge/passes/6-compile.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function calculateConfidence(count) {
+  if (count >= 7) return "high";
+  if (count >= 3) return "medium";
+  return "low";
+}
+function compileKnowledge(clusters, existingItems, observations, project, now) {
+  const itemMap = new Map(existingItems.map((i) => [i.id, { ...i }]));
+  const obsMap = new Map(observations.map((o) => [o.id, o]));
+  const result = {
+    created: [],
+    reinforced: [],
+    superseded: [],
+    deprecated: [],
+    ignored: 0
+  };
+  for (const cluster of clusters) {
+    const obs = obsMap.get(cluster.observationId);
+    if (!obs) continue;
+    switch (cluster.action) {
+      case "CREATE": {
+        const newItem = {
+          id: `ki_${randomUUID2().slice(0, 8)}`,
+          canonicalHash: computeCanonicalHash(obs.content),
+          type: obs.type,
+          title: obs.content.slice(0, 80),
+          content: obs.content,
+          confidence: "low",
+          observationCount: 1,
+          authority: "AUTO",
+          status: "active",
+          supersededById: void 0,
+          enforce: false,
+          project,
+          scope: obs.scope || (obs.type === "rule" || obs.type === "lesson" ? "global" : "project"),
+          createdAt: now,
+          updatedAt: now,
+          lastSeenAt: now,
+          metadata: {}
+        };
+        result.created.push(newItem);
+        break;
+      }
+      case "REINFORCE": {
+        const target = itemMap.get(cluster.targetKnowledgeItemId);
+        if (!target) break;
+        target.observationCount += 1;
+        target.lastSeenAt = now;
+        target.updatedAt = now;
+        target.confidence = calculateConfidence(target.observationCount);
+        result.reinforced.push(target);
+        break;
+      }
+      case "SUPERSEDE": {
+        const target = itemMap.get(cluster.targetKnowledgeItemId);
+        if (target) {
+          const newItem = {
+            id: `ki_${randomUUID2().slice(0, 8)}`,
+            canonicalHash: computeCanonicalHash(obs.content),
+            type: obs.type,
+            title: obs.content.slice(0, 80),
+            content: obs.content,
+            confidence: "low",
+            observationCount: 1,
+            authority: "AUTO",
+            status: "active",
+            supersededById: void 0,
+            enforce: false,
+            project,
+            scope: obs.scope || (obs.type === "rule" || obs.type === "lesson" ? "global" : "project"),
+            createdAt: now,
+            updatedAt: now,
+            lastSeenAt: now,
+            metadata: {}
+          };
+          target.status = "superseded";
+          target.updatedAt = now;
+          target.supersededById = newItem.id;
+          result.superseded.push(target);
+          result.created.push(newItem);
+        }
+        break;
+      }
+      case "DEPRECATE": {
+        const target = itemMap.get(cluster.targetKnowledgeItemId);
+        if (target) {
+          target.status = "deprecated";
+          target.updatedAt = now;
+          result.deprecated.push(target);
+        }
+        break;
+      }
+      case "IGNORE":
+        result.ignored += 1;
+        break;
+    }
+  }
+  return result;
+}
+
+// src/knowledge/passes/7-projector.ts
+import { mkdirSync, writeFileSync } from "fs";
+function projectToMarkdown(items, generatedDir, compilerVersion) {
+  mkdirSync(generatedDir, { recursive: true });
+  const active = items.filter((i) => i.status === "active");
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const header = (title) => `<!-- AUTO-GENERATED BY AGENTCACHE v${compilerVersion} \u2014 DO NOT EDIT -->
+<!-- Source of truth: .agentcache/agentcache.db -->
+<!-- Last compiled: ${timestamp} | ${active.length} active items -->
+
+# ${title}
+
+`;
+  const rules = active.filter((i) => i.type === "rule").sort((a, b) => confidenceOrder(b) - confidenceOrder(a));
+  const lessons = active.filter((i) => i.type === "lesson").sort((a, b) => confidenceOrder(b) - confidenceOrder(a));
+  const decisions = active.filter((i) => i.type === "decision").sort((a, b) => confidenceOrder(b) - confidenceOrder(a));
+  const context = active.filter((i) => i.type === "context").sort((a, b) => b.lastSeenAt - a.lastSeenAt);
+  writeFileSync(
+    `${generatedDir}/RULES.md`,
+    header("Rules") + formatItems(rules),
+    "utf-8"
+  );
+  writeFileSync(
+    `${generatedDir}/LESSONS.md`,
+    header("Lessons") + formatItems(lessons),
+    "utf-8"
+  );
+  writeFileSync(
+    `${generatedDir}/DECISIONS.md`,
+    header("Decisions") + formatItems(decisions),
+    "utf-8"
+  );
+  writeFileSync(
+    `${generatedDir}/CONTEXT.md`,
+    header("Context") + formatItems(context),
+    "utf-8"
+  );
+}
+function confidenceOrder(item) {
+  switch (item.confidence) {
+    case "high":
+      return 3;
+    case "medium":
+      return 2;
+    case "low":
+      return 1;
+  }
+}
+function formatItems(items) {
+  if (items.length === 0) return "_No items yet._\n";
+  return items.map((i) => {
+    const badge = i.enforce ? " \u{1F6E1}\uFE0F" : "";
+    const conf = `(${i.confidence}, ${i.observationCount}\xD7)`;
+    return `- ${i.content}${badge} ${conf}`;
+  }).join("\n") + "\n";
+}
+
+// src/knowledge/compiler.ts
+var COMPILER_VERSION = "0.1.0";
+function startCompile(events, sessionId, project, projectRoot, repo, transcriptPath) {
+  const git = getGitContext(projectRoot);
+  const session = {
+    id: sessionId,
+    project,
+    startedAt: Date.now() - 6e4,
+    endedAt: Date.now(),
+    gitBranch: git.branch,
+    gitCommit: git.commit,
+    provider: "agent",
+    model: "host-agent",
+    transcriptPath: transcriptPath || "",
+    observationCount: 0
+  };
+  repo.saveSession(session);
+  const prompt = buildExtractionPrompt(events);
+  return { sessionId, project, projectRoot, prompt };
+}
+function processExtraction(repo, responseText, sessionId, project, projectRoot) {
+  const rawObservations = parseExtractionResponse(responseText, sessionId, project);
+  const normalized = normalize(rawObservations);
+  const existingItems = repo.getKnowledgeItems(project, { status: "active" });
+  const existingKeys = existingItems.map((i) => computeCanonicalKey(i.content));
+  const canonicalized = canonicalize(normalized, existingKeys);
+  for (const obs of canonicalized.autoReinforced) {
+    const matchingItem = existingItems.find(
+      (item) => computeCanonicalKey(item.content) === obs.canonicalKey
+    );
+    if (matchingItem) {
+      const newCount = matchingItem.observationCount + 1;
+      const confidence = newCount >= 7 ? "high" : newCount >= 3 ? "medium" : "low";
+      repo.updateKnowledgeItem(matchingItem.id, {
+        observationCount: newCount,
+        lastSeenAt: Date.now(),
+        updatedAt: Date.now(),
+        confidence
+      });
+    }
+  }
+  repo.saveObservations(normalized);
+  if (canonicalized.needsClustering.length === 0) {
+    saveCompileRun(repo, sessionId, project, normalized.length, canonicalized.autoReinforced.length, 0, 0, 0, 0, 0, Date.now());
+    projectToMarkdown(repo.getKnowledgeItems(project, { status: "active" }), getDataDir(), COMPILER_VERSION);
+    return {
+      status: "complete",
+      diagnostics: formatDiagnostics(normalized.length, canonicalized.autoReinforced.length, 0, 0, 0, 0, 0, project, sessionId)
+    };
+  }
+  const clusteringPrompt = buildClusteringPrompt(canonicalized.needsClustering, existingItems);
+  return {
+    status: "needs_clustering",
+    clusteringPrompt,
+    sessionId
+  };
+}
+function processClustering(repo, responseText, sessionId, project, projectRoot) {
+  const startedAt = Date.now();
+  const existingItems = repo.getKnowledgeItems(project, { status: "active" });
+  const observations = repo.getObservations(project);
+  const sessionObs = observations.filter((o) => o.sessionId === sessionId);
+  const canonicalized = canonicalize(sessionObs);
+  const needsClustering = canonicalized.needsClustering;
+  const clusters = parseClusteringResponse(responseText, needsClustering);
+  const contradictions = [];
+  const supersedeActions = clusters.filter((c) => c.action === "SUPERSEDE");
+  for (const s of supersedeActions) {
+    if (s.targetKnowledgeItemId) {
+      const target = existingItems.find((i) => i.id === s.targetKnowledgeItemId);
+      if (target) {
+        contradictions.push({
+          id: `con_${randomUUID3().slice(0, 8)}`,
+          project,
+          itemAId: target.id,
+          itemBId: s.observationId,
+          topic: target.title.slice(0, 50),
+          description: `"${target.content}" superseded by new observation`,
+          recommendation: "keep_newer",
+          resolved: false,
+          createdAt: Date.now()
+        });
+      }
+    }
+  }
+  for (const c of contradictions) {
+    repo.saveContradiction(c);
+  }
+  const now = Date.now();
+  const compiled = compileKnowledge(clusters, existingItems, needsClustering, project, now);
+  for (const item of compiled.created) repo.saveKnowledgeItem(item);
+  for (const item of compiled.reinforced) {
+    repo.updateKnowledgeItem(item.id, {
+      observationCount: item.observationCount,
+      lastSeenAt: item.lastSeenAt,
+      updatedAt: item.updatedAt,
+      confidence: item.confidence
+    });
+  }
+  for (const item of compiled.superseded) {
+    repo.updateKnowledgeItem(item.id, {
+      status: item.status,
+      updatedAt: item.updatedAt,
+      supersededById: item.supersededById
+    });
+  }
+  for (const item of compiled.deprecated) {
+    repo.updateKnowledgeItem(item.id, { status: item.status, updatedAt: item.updatedAt });
+  }
+  const totalObs = sessionObs.length;
+  saveCompileRun(repo, sessionId, project, totalObs, 0, compiled.created.length, compiled.reinforced.length, compiled.superseded.length, compiled.deprecated.length, compiled.ignored, startedAt);
+  projectToMarkdown(repo.getKnowledgeItems(project, { status: "active" }), getDataDir(), COMPILER_VERSION);
+  return {
+    status: "complete",
+    diagnostics: formatDiagnostics(totalObs, 0, compiled.created.length, compiled.reinforced.length, compiled.superseded.length, compiled.deprecated.length, compiled.ignored, project, sessionId)
+  };
+}
+function saveCompileRun(repo, sessionId, project, observationsProcessed, autoReinforced, created, reinforced, superseded, deprecated, ignored, startedAt) {
+  const endedAt = Date.now();
+  const run = {
+    id: `cr_${randomUUID3().slice(0, 8)}`,
+    project,
+    sessionId,
+    compilerVersion: COMPILER_VERSION,
+    promptVersions: { extract: EXTRACT_PROMPT_VERSION, cluster: CLUSTER_PROMPT_VERSION, contradiction: CONTRADICTION_PROMPT_VERSION },
+    startedAt,
+    endedAt,
+    durationMs: endedAt - startedAt,
+    observationsProcessed,
+    knowledgeCreated: created,
+    knowledgeReinforced: reinforced + autoReinforced,
+    knowledgeDeprecated: deprecated,
+    knowledgeSuperseded: superseded,
+    knowledgeIgnored: ignored,
+    contradictionsDetected: 0,
+    diagnostics: ""
+  };
+  repo.saveCompileRun(run);
+}
+function formatDiagnostics(extracted, autoReinforced, created, reinforced, superseded, deprecated, ignored, project, sessionId) {
+  return [
+    `AgentCache Compiler v${COMPILER_VERSION}`,
+    `Project: ${project} | Session: ${sessionId}`,
+    `  ${extracted} observations processed`,
+    autoReinforced > 0 ? `  ${autoReinforced} auto-reinforced (no LLM needed)` : "",
+    `  ${created} new knowledge items`,
+    `  ${reinforced} reinforced`,
+    superseded > 0 ? `  ${superseded} superseded` : "",
+    deprecated > 0 ? `  ${deprecated} deprecated` : "",
+    ignored > 0 ? `  ${ignored} ignored` : ""
+  ].filter(Boolean).join("\n");
+}
+
+export {
+  computeCanonicalHash,
+  startCompile,
+  processExtraction,
+  processClustering
+};

package/dist/chunk-KFQGP6VL.js

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+export {
+  __require,
+  __esm,
+  __export,
+  __toCommonJS
+};