@vpxa/kb 0.1.13 → 0.1.16

package/packages/embeddings/dist/embedder.interface.d.ts

@@ -1,24 +1,26 @@
+//#region packages/embeddings/src/embedder.interface.d.ts
 /**
  * Embedding abstraction — allows swapping embedding models.
  */
-export interface IEmbedder {
-    /** Generate an embedding vector for a single text string (used for documents/passages) */
-    embed(text: string): Promise<Float32Array>;
-    /**
-     * Generate an embedding vector for a search query.
-     * Some models (e.g., BGE) use a query prefix for asymmetric retrieval.
-     * Falls back to embed() if the model doesn't need query prefixing.
-     */
-    embedQuery(query: string): Promise<Float32Array>;
-    /** Generate embeddings for multiple text strings (batched, for documents/passages) */
-    embedBatch(texts: string[]): Promise<Float32Array[]>;
-    /** The dimensionality of the embedding vectors */
-    readonly dimensions: number;
-    /** The model identifier */
-    readonly modelId: string;
-    /** Initialize the model (download if needed, load into memory) */
-    initialize(): Promise<void>;
-    /** Release model resources */
-    shutdown?(): Promise<void>;
+interface IEmbedder {
+  /** Generate an embedding vector for a single text string (used for documents/passages) */
+  embed(text: string): Promise<Float32Array>;
+  /**
+   * Generate an embedding vector for a search query.
+   * Some models (e.g., BGE) use a query prefix for asymmetric retrieval.
+   * Falls back to embed() if the model doesn't need query prefixing.
+   */
+  embedQuery(query: string): Promise<Float32Array>;
+  /** Generate embeddings for multiple text strings (batched, for documents/passages) */
+  embedBatch(texts: string[]): Promise<Float32Array[]>;
+  /** The dimensionality of the embedding vectors */
+  readonly dimensions: number;
+  /** The model identifier */
+  readonly modelId: string;
+  /** Initialize the model (download if needed, load into memory) */
+  initialize(): Promise<void>;
+  /** Release model resources */
+  shutdown?(): Promise<void>;
 }
-//# sourceMappingURL=embedder.interface.d.ts.map
+//#endregion
+export { IEmbedder };

package/packages/embeddings/dist/embedder.interface.js

@@ -0,0 +1 @@
+export{};

package/packages/embeddings/dist/index.d.ts

@@ -1,3 +1,3 @@
-export type { IEmbedder } from './embedder.interface.js';
-export { OnnxEmbedder } from './onnx-embedder.js';
-//# sourceMappingURL=index.d.ts.map
+import { IEmbedder } from "./embedder.interface.js";
+import { OnnxEmbedder } from "./onnx-embedder.js";
+export { type IEmbedder, OnnxEmbedder };

package/packages/embeddings/dist/index.js

@@ -1 +1 @@
-import{OnnxEmbedder as d}from"./onnx-embedder.js";export{d as OnnxEmbedder};
+import{OnnxEmbedder as e}from"./onnx-embedder.js";export{e as OnnxEmbedder};

package/packages/embeddings/dist/onnx-embedder.d.ts

@@ -1,24 +1,22 @@
-/**
- * ONNX-based embedder using @huggingface/transformers.
- * Uses mixedbread-ai/mxbai-embed-large-v1 (1024 dimensions, ~1.3GB ONNX model).
- * BGE-derived models use query prefixing for asymmetric retrieval (short query → long document).
- */
-import type { IEmbedder } from './embedder.interface.js';
-export declare class OnnxEmbedder implements IEmbedder {
-    private pipe;
-    readonly dimensions: number;
-    readonly modelId: string;
-    private readonly queryPrefix;
-    constructor(options?: {
-        model?: string;
-        dimensions?: number;
-        queryPrefix?: string;
-    });
-    private detectQueryPrefix;
-    initialize(): Promise<void>;
-    shutdown(): Promise<void>;
-    embed(text: string): Promise<Float32Array>;
-    embedQuery(query: string): Promise<Float32Array>;
-    embedBatch(texts: string[]): Promise<Float32Array[]>;
+import { IEmbedder } from "./embedder.interface.js";
+
+//#region packages/embeddings/src/onnx-embedder.d.ts
+declare class OnnxEmbedder implements IEmbedder {
+  private pipe;
+  readonly dimensions: number;
+  readonly modelId: string;
+  private readonly queryPrefix;
+  constructor(options?: {
+    model?: string;
+    dimensions?: number;
+    queryPrefix?: string;
+  });
+  private detectQueryPrefix;
+  initialize(): Promise<void>;
+  shutdown(): Promise<void>;
+  embed(text: string): Promise<Float32Array>;
+  embedQuery(query: string): Promise<Float32Array>;
+  embedBatch(texts: string[]): Promise<Float32Array[]>;
 }
-//# sourceMappingURL=onnx-embedder.d.ts.map
+//#endregion
+export { OnnxEmbedder };

package/packages/embeddings/dist/onnx-embedder.js

@@ -1 +1 @@
-import{homedir as m}from"node:os";import{join as u}from"node:path";import{env as p,pipeline as c}from"@huggingface/transformers";import{EMBEDDING_DEFAULTS as l}from"../../core/dist/index.js";p.cacheDir=u(m(),".cache","huggingface","transformers-js");class w{pipe=null;dimensions;modelId;queryPrefix;constructor(e){this.modelId=e?.model??l.model,this.dimensions=e?.dimensions??l.dimensions,this.queryPrefix=e?.queryPrefix??this.detectQueryPrefix(this.modelId)}detectQueryPrefix(e){const i=e.toLowerCase();return i.includes("bge")||i.includes("mxbai-embed")?"Represent this sentence for searching relevant passages: ":i.includes("/e5-")||i.includes("multilingual-e5")?"query: ":""}async initialize(){if(!this.pipe)try{this.pipe=await c("feature-extraction",this.modelId,{dtype:"fp32"})}catch(e){throw new Error(`Failed to initialize embedding model "${this.modelId}": ${e.message}`)}}async shutdown(){this.pipe=null}async embed(e){this.pipe||await this.initialize();const i=await this.pipe?.(e,{pooling:"mean",normalize:!0});if(!i)throw new Error("Embedding pipeline returned no output");return new Float32Array(i.data)}async embedQuery(e){return this.embed(this.queryPrefix+e)}async embedBatch(e){if(e.length===0)return[];this.pipe||await this.initialize();const i=[],o=32;for(let r=0;r<e.length;r+=o){const t=e.slice(r,r+o),n=await this.pipe?.(t,{pooling:"mean",normalize:!0});if(!n)throw new Error("Embedding pipeline returned no output");if(t.length===1)i.push(new Float32Array(n.data));else for(let s=0;s<t.length;s++){const a=s*this.dimensions,d=n.data.slice(a,a+this.dimensions);i.push(new Float32Array(d))}}return i}}export{w as OnnxEmbedder};
+import{homedir as e}from"node:os";import{join as t}from"node:path";import{env as n,pipeline as r}from"@huggingface/transformers";import{EMBEDDING_DEFAULTS as i}from"../../core/dist/index.js";n.cacheDir=t(e(),`.cache`,`huggingface`,`transformers-js`);var a=class{pipe=null;dimensions;modelId;queryPrefix;constructor(e){this.modelId=e?.model??i.model,this.dimensions=e?.dimensions??i.dimensions,this.queryPrefix=e?.queryPrefix??this.detectQueryPrefix(this.modelId)}detectQueryPrefix(e){let t=e.toLowerCase();return t.includes(`bge`)||t.includes(`mxbai-embed`)?`Represent this sentence for searching relevant passages: `:t.includes(`/e5-`)||t.includes(`multilingual-e5`)?`query: `:``}async initialize(){if(!this.pipe)try{this.pipe=await r(`feature-extraction`,this.modelId,{dtype:`fp32`})}catch(e){throw Error(`Failed to initialize embedding model "${this.modelId}": ${e.message}`)}}async shutdown(){this.pipe=null}async embed(e){this.pipe||await this.initialize();let t=await this.pipe?.(e,{pooling:`mean`,normalize:!0});if(!t)throw Error(`Embedding pipeline returned no output`);return new Float32Array(t.data)}async embedQuery(e){return this.embed(this.queryPrefix+e)}async embedBatch(e){if(e.length===0)return[];this.pipe||await this.initialize();let t=[];for(let n=0;n<e.length;n+=32){let r=e.slice(n,n+32),i=await this.pipe?.(r,{pooling:`mean`,normalize:!0});if(!i)throw Error(`Embedding pipeline returned no output`);if(r.length===1)t.push(new Float32Array(i.data));else for(let e=0;e<r.length;e++){let n=e*this.dimensions,r=i.data.slice(n,n+this.dimensions);t.push(new Float32Array(r))}}return t}};export{a as OnnxEmbedder};

package/packages/enterprise-bridge/dist/cache.d.ts

@@ -0,0 +1,28 @@
+import { ERSearchResult } from "./types.js";
+
+//#region packages/enterprise-bridge/src/cache.d.ts
+declare class ERCache {
+  private readonly cache;
+  private readonly maxEntries;
+  private readonly defaultTtl;
+  constructor(options?: {
+    maxEntries?: number;
+    defaultTtl?: number;
+  });
+  /** Normalize query for cache key: lowercase, trim, collapse whitespace */
+  static normalizeKey(query: string): string;
+  get(query: string): ERSearchResult[] | undefined;
+  set(query: string, results: ERSearchResult[], ttl?: number): void;
+  /** Invalidate entries matching a topic (exact normalized key match) */
+  invalidate(query: string): boolean;
+  clear(): void;
+  get size(): number;
+  /** Get cache stats */
+  stats(): {
+    size: number;
+    maxEntries: number;
+    defaultTtlMs: number;
+  };
+}
+//#endregion
+export { ERCache };

package/packages/enterprise-bridge/dist/cache.js

@@ -0,0 +1 @@
+var e=class e{cache=new Map;maxEntries;defaultTtl;constructor(e){this.maxEntries=e?.maxEntries??100,this.defaultTtl=e?.defaultTtl??216e5}static normalizeKey(e){return e.toLowerCase().trim().replace(/\s+/g,` `)}get(t){let n=e.normalizeKey(t),r=this.cache.get(n);if(r){if(Date.now()-r.cachedAt>r.ttl){this.cache.delete(n);return}return this.cache.delete(n),this.cache.set(n,r),r.results}}set(t,n,r){let i=e.normalizeKey(t);if(this.cache.size>=this.maxEntries&&!this.cache.has(i)){let e=this.cache.keys().next().value;e!==void 0&&this.cache.delete(e)}this.cache.set(i,{results:n,query:i,cachedAt:Date.now(),ttl:r??this.defaultTtl})}invalidate(t){let n=e.normalizeKey(t);return this.cache.delete(n)}clear(){this.cache.clear()}get size(){return this.cache.size}stats(){return{size:this.cache.size,maxEntries:this.maxEntries,defaultTtlMs:this.defaultTtl}}};export{e as ERCache};

package/packages/enterprise-bridge/dist/er-client.d.ts

@@ -0,0 +1,37 @@
+import { ERBridgeConfig, ERPushRequest, ERPushResponse, ERSearchResult } from "./types.js";
+
+//#region packages/enterprise-bridge/src/er-client.d.ts
+declare class ERClient {
+  private readonly baseUrl;
+  private readonly apiKey;
+  private readonly timeoutMs;
+  private circuitState;
+  private consecutiveFailures;
+  private openUntil;
+  private halfOpenProbeInFlight;
+  private static readonly FAILURE_THRESHOLD;
+  private static readonly RESET_TIMEOUT_MS;
+  constructor(config: ERBridgeConfig);
+  /** Search ER knowledge base */
+  search(query: string, maxResults?: number): Promise<ERSearchResult[]>;
+  /** Push curated knowledge to ER via MCP tools endpoint */
+  push(request: ERPushRequest): Promise<ERPushResponse>;
+  /** Explicit pull from ER (bypasses local search, for cross-repo context) */
+  pull(query: string, maxResults?: number): Promise<ERSearchResult[]>;
+  /** Check ER health */
+  health(): Promise<{
+    healthy: boolean;
+    status?: number;
+  }>;
+  /** Check available MCP tools (verify curated_remember exists) */
+  listTools(): Promise<string[]>;
+  private fetch;
+  private checkCircuit;
+  private recordSuccess;
+  private recordFailure;
+  private backoffMs;
+  private parseRetryAfter;
+  private sleep;
+}
+//#endregion
+export { ERClient };

package/packages/enterprise-bridge/dist/er-client.js

@@ -0,0 +1 @@
+import{ERTransientError as e}from"./types.js";var t=class t{baseUrl;apiKey;timeoutMs;circuitState=`closed`;consecutiveFailures=0;openUntil=0;halfOpenProbeInFlight=!1;static FAILURE_THRESHOLD=3;static RESET_TIMEOUT_MS=6e4;constructor(e){let t=new URL(e.baseUrl);if(t.protocol!==`http:`&&t.protocol!==`https:`)throw Error(`Unsupported protocol: ${t.protocol} — only http/https allowed`);let n=t.hostname===`localhost`||t.hostname===`127.0.0.1`||t.hostname===`::1`;if(t.protocol===`http:`&&!n)throw Error(`Non-TLS (http://) ER endpoints are only allowed for localhost. Use https:// to avoid leaking API keys.`);this.baseUrl=e.baseUrl.replace(/\/+$/,``),this.apiKey=e.apiKey,this.timeoutMs=e.timeoutMs}async search(e,t=5){let n=await this.fetch(`/api/v1/search`,{method:`POST`,body:JSON.stringify({query:e,maxResults:t,generateResponse:!1})});if(!n.ok)throw Error(`ER search failed: ${n.status} ${n.statusText}`);return((await n.json()).sources??[]).map(e=>{let t=typeof e.score==`number`?e.score:void 0,n=typeof e.confidence==`number`?e.confidence:void 0;return{content:e.content,sourcePath:e.metadata?.sourceUri??`unknown`,score:t??n??0,metadata:e.metadata}})}async push(e){let t=await this.fetch(`/mcp/tools`,{method:`POST`,body:JSON.stringify({name:`curated_remember`,arguments:{title:e.title,content:e.content,category:e.category??`conventions`,tags:[...e.tags??[],`pushed-from-kb`]}})});if(!t.ok)return{pushed:!1,status:`failed`,timestamp:new Date().toISOString(),error:`ER push failed: ${t.status} ${t.statusText}`};let n=await t.json();return{pushed:!0,status:`stored`,remotePath:typeof n.path==`string`?n.path:void 0,timestamp:new Date().toISOString()}}async pull(e,t=10){return this.search(e,t)}async health(){try{let e=await this.fetch(`/api/v1/health`,{method:`GET`});return{healthy:e.ok,status:e.status}}catch{return{healthy:!1}}}async listTools(){try{let e=await this.fetch(`/mcp/tools`,{method:`GET`});return e.ok?((await e.json()).tools??[]).map(e=>e.name):[]}catch{return[]}}async fetch(e,t){this.checkCircuit();let n;for(let r=0;r<=2;r++){let i=new AbortController,a=setTimeout(()=>i.abort(),this.timeoutMs);try{let n=await fetch(`${this.baseUrl}${e}`,{...t,headers:{"Content-Type":`application/json`,"X-Api-Key":this.apiKey,"User-Agent":`kb-enterprise-bridge/1.0`,...t.headers},signal:i.signal});if(n.ok||n.status>=400&&n.status<500&&n.status!==429)return this.recordSuccess(),n;if(r<2){let e=this.parseRetryAfter(n)??this.backoffMs(r);await this.sleep(e);continue}return this.recordFailure(),n}catch(e){n=e,r<2&&await this.sleep(this.backoffMs(r))}finally{clearTimeout(a)}}throw this.recordFailure(),n??Error(`Fetch failed after retries`)}checkCircuit(){if(this.circuitState===`open`)if(Date.now()>=this.openUntil){if(this.halfOpenProbeInFlight)throw new e(`ER circuit breaker is half-open — probe in progress`);this.circuitState=`half-open`,this.halfOpenProbeInFlight=!0}else throw new e(`ER circuit breaker is open — skipping request`)}recordSuccess(){this.consecutiveFailures=0,this.circuitState=`closed`,this.halfOpenProbeInFlight=!1}recordFailure(){this.consecutiveFailures++,this.halfOpenProbeInFlight=!1,this.consecutiveFailures>=t.FAILURE_THRESHOLD&&(this.circuitState=`open`,this.openUntil=Date.now()+t.RESET_TIMEOUT_MS)}backoffMs(e){let t=500*3**e,n=t*.25*(Math.random()*2-1);return Math.round(t+n)}parseRetryAfter(e){let t=e.headers.get(`Retry-After`);if(!t)return;let n=Number(t);if(!Number.isNaN(n)&&n>=0)return Math.min(n*1e3,3e4)}sleep(e){return new Promise(t=>setTimeout(t,e))}};export{t as ERClient};

package/packages/enterprise-bridge/dist/evolution-collector.d.ts

@@ -0,0 +1,62 @@
+//#region packages/enterprise-bridge/src/evolution-collector.d.ts
+/** Evolution data collector — tracks usage metrics for LLM review */
+interface EvolutionMetrics {
+  /** Search metrics */
+  search: {
+    totalSearches: number;
+    erFallbackCount: number;
+    erFallbackRate: number;
+    erCacheHitCount: number;
+    erCacheHitRate: number;
+    topMissedQueries: Array<{
+      query: string;
+      count: number;
+    }>;
+  };
+  /** Push metrics */
+  push: {
+    totalPushes: number;
+    successCount: number;
+    failCount: number;
+    pushRate: number; /** Classification match rate — how often rules fired vs knowledge stored */
+    classificationMatchRate: number; /** Push acceptance rate — how often LLM decided to push after recommendation */
+    pushAcceptanceRate: number;
+  };
+  /** Rule effectiveness */
+  rules: {
+    matchCounts: Record<string, number>;
+    pushCounts: Record<string, number>; /** Rules that fire often but rarely lead to pushes (potential false positives) */
+    lowConversionRules: Array<{
+      ruleId: string;
+      matchCount: number;
+      pushCount: number;
+      conversionRate: number;
+    }>;
+  };
+  /** Summary period */
+  period: {
+    startedAt: string;
+    queriedAt: string;
+    totalEvents: number;
+  };
+}
+declare class EvolutionCollector {
+  private searchEvents;
+  private classificationEvents;
+  private pushEvents;
+  private readonly startedAt;
+  constructor();
+  /** Record a search event */
+  recordSearch(query: string, erFallbackTriggered: boolean, erCacheHit: boolean): void;
+  /** Record a classification event (when remember returns classification signals) */
+  recordClassification(entryTitle: string, matchingRuleIds: string[], pushRecommended: boolean): void;
+  /** Record a push event */
+  recordPush(entryId: string, success: boolean, ruleId?: string): void;
+  /** Get aggregated metrics for LLM review */
+  getMetrics(): EvolutionMetrics;
+  /** Reset all collected data */
+  reset(): void;
+  private trimEvents;
+}
+//#endregion
+export { EvolutionCollector, EvolutionMetrics };

package/packages/enterprise-bridge/dist/evolution-collector.js

@@ -0,0 +1 @@
+var e=class{searchEvents=[];classificationEvents=[];pushEvents=[];startedAt;constructor(){this.startedAt=new Date().toISOString()}recordSearch(e,t,n){this.searchEvents.push({query:e.toLowerCase().trim(),erFallbackTriggered:t,erCacheHit:n,timestamp:Date.now()}),this.trimEvents()}recordClassification(e,t,n){this.classificationEvents.push({entryTitle:e,matchingRuleIds:t,pushRecommended:n,timestamp:Date.now()}),this.trimEvents()}recordPush(e,t,n){this.pushEvents.push({entryId:e,ruleId:n,success:t,timestamp:Date.now()}),this.trimEvents()}getMetrics(){let e=this.searchEvents.length,t=this.searchEvents.filter(e=>e.erFallbackTriggered).length,n=this.searchEvents.filter(e=>e.erCacheHit).length,r=new Map;for(let e of this.searchEvents)e.erFallbackTriggered&&r.set(e.query,(r.get(e.query)??0)+1);let i=[...r.entries()].sort((e,t)=>t[1]-e[1]).slice(0,20).map(([e,t])=>({query:e,count:t})),a=this.pushEvents.length,o=this.pushEvents.filter(e=>e.success).length,s=this.classificationEvents.length,c=this.classificationEvents.filter(e=>e.pushRecommended).length,l={},u={};for(let e of this.classificationEvents)for(let t of e.matchingRuleIds)l[t]=(l[t]??0)+1;for(let e of this.pushEvents)e.ruleId&&(u[e.ruleId]=(u[e.ruleId]??0)+1);let d=Object.entries(l).map(([e,t])=>{let n=u[e]??0;return{ruleId:e,matchCount:t,pushCount:n,conversionRate:t>0?n/t:0}}).filter(e=>e.matchCount>=3&&e.conversionRate<.3).sort((e,t)=>e.conversionRate-t.conversionRate);return{search:{totalSearches:e,erFallbackCount:t,erFallbackRate:e>0?t/e:0,erCacheHitCount:n,erCacheHitRate:t>0?n/t:0,topMissedQueries:i},push:{totalPushes:a,successCount:o,failCount:a-o,pushRate:s>0?a/s:0,classificationMatchRate:s>0?c/s:0,pushAcceptanceRate:c>0?a/c:0},rules:{matchCounts:l,pushCounts:u,lowConversionRules:d},period:{startedAt:this.startedAt,queriedAt:new Date().toISOString(),totalEvents:this.searchEvents.length+this.classificationEvents.length+this.pushEvents.length}}}reset(){this.searchEvents=[],this.classificationEvents=[],this.pushEvents=[]}trimEvents(){this.searchEvents.length>500&&(this.searchEvents=this.searchEvents.slice(-500)),this.classificationEvents.length>500&&(this.classificationEvents=this.classificationEvents.slice(-500)),this.pushEvents.length>500&&(this.pushEvents=this.pushEvents.slice(-500))}};export{e as EvolutionCollector};

package/packages/enterprise-bridge/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { ERBridgeConfig, ERCacheEntry, ERPushRequest, ERPushResponse, ERSearchResponse, ERSearchResult, ERSyncEntry, ERTransientError, MergedSearchResult } from "./types.js";
+import { ERCache } from "./cache.js";
+import { ERClient } from "./er-client.js";
+import { EvolutionCollector, EvolutionMetrics } from "./evolution-collector.js";
+import { ClassificationResult, ClassificationRule, PolicyStore } from "./policy-store.js";
+import { PushAdapter } from "./push-adapter.js";
+import { mergeResults } from "./result-merger.js";
+export { type ClassificationResult, type ClassificationRule, type ERBridgeConfig, ERCache, type ERCacheEntry, ERClient, type ERPushRequest, type ERPushResponse, type ERSearchResponse, type ERSearchResult, type ERSyncEntry, ERTransientError, EvolutionCollector, type EvolutionMetrics, type MergedSearchResult, PolicyStore, PushAdapter, mergeResults };

package/packages/enterprise-bridge/dist/index.js

@@ -0,0 +1 @@
+import{ERCache as e}from"./cache.js";import{ERTransientError as t}from"./types.js";import{ERClient as n}from"./er-client.js";import{EvolutionCollector as r}from"./evolution-collector.js";import{PolicyStore as i}from"./policy-store.js";import{PushAdapter as a}from"./push-adapter.js";import{mergeResults as o}from"./result-merger.js";export{e as ERCache,n as ERClient,t as ERTransientError,r as EvolutionCollector,i as PolicyStore,a as PushAdapter,o as mergeResults};

package/packages/enterprise-bridge/dist/policy-store.d.ts

@@ -0,0 +1,45 @@
+//#region packages/enterprise-bridge/src/policy-store.d.ts
+/** A single classification rule */
+interface ClassificationRule {
+  id: string;
+  patterns: string[];
+  category: string;
+  pushWeight: number;
+  description: string;
+  examples: string[];
+  autoPush: false;
+  enabled: boolean;
+  createdAt: string;
+  updatedAt: string;
+}
+/** Classification result for a knowledge entry */
+interface ClassificationResult {
+  matchingRules: Array<{
+    ruleId: string;
+    category: string;
+    pushWeight: number;
+    matchedPatterns: string[];
+  }>;
+  pushRecommended: boolean;
+  maxPushWeight: number;
+}
+declare class PolicyStore {
+  private rules;
+  private readonly rulesPath;
+  constructor(curatedPath: string);
+  /** Classify a knowledge entry against all enabled rules */
+  classify(title: string, content: string, tags: string[]): ClassificationResult;
+  /** Get all rules */
+  getRules(): ClassificationRule[];
+  /** Get a single rule by ID */
+  getRule(ruleId: string): ClassificationRule | undefined;
+  /** Update an existing rule */
+  updateRule(ruleId: string, changes: Partial<Omit<ClassificationRule, 'id' | 'createdAt' | 'autoPush'>>): ClassificationRule | undefined;
+  /** Add a new rule */
+  addRule(rule: Omit<ClassificationRule, 'createdAt' | 'updatedAt' | 'autoPush'>): ClassificationRule;
+  /** Delete a rule */
+  deleteRule(ruleId: string): boolean;
+  private save;
+}
+//#endregion
+export { ClassificationResult, ClassificationRule, PolicyStore };

package/packages/enterprise-bridge/dist/policy-store.js

@@ -0,0 +1 @@
+import{existsSync as e,mkdirSync as t,readFileSync as n,writeFileSync as r}from"node:fs";import{join as i}from"node:path";import{createLogger as a}from"../../core/dist/index.js";const o=a(`bridge`),s=()=>new Date().toISOString(),c=[{id:`cross-repo-contract`,patterns:[`contract`,`interface`,`api`,`event schema`,`publishes`,`subscribes`],category:`contract`,pushWeight:.8,description:`Knowledge describing cross-service interfaces`,examples:[`Service X publishes OrderCreated event with fields...`],autoPush:!1,enabled:!0,createdAt:s(),updatedAt:s()},{id:`architecture-decision`,patterns:[`decided`,`chose`,`tradeoff`,`adr`,`because we need`],category:`decision`,pushWeight:.7,description:`Architecture decisions that affect the ecosystem`,examples:[`We decided to use event sourcing because...`],autoPush:!1,enabled:!0,createdAt:s(),updatedAt:s()},{id:`shared-pattern`,patterns:[`pattern`,`convention`,`standard`,`guideline`,`always use`],category:`pattern`,pushWeight:.6,description:`Patterns and conventions that maintain consistency across repos`,examples:[`Always use the Result type for error handling...`],autoPush:!1,enabled:!0,createdAt:s(),updatedAt:s()},{id:`company-term`,patterns:[`means`,`defined as`,`acronym`,`refers to`],category:`glossary`,pushWeight:.7,description:`Shared vocabulary and terminology definitions`,examples:[`DDD means Domain-Driven Design in our context...`],autoPush:!1,enabled:!0,createdAt:s(),updatedAt:s()},{id:`implementation-detail`,patterns:[`private`,`internal`,`helper`,`todo`,`hack`,`workaround`],category:`local-only`,pushWeight:0,description:`Local-only implementation details — never push`,examples:[`TODO: refactor this helper`,`Internal workaround for...`],autoPush:!1,enabled:!0,createdAt:s(),updatedAt:s()}];var l=class{rules=[];rulesPath;constructor(r){let a=i(r,`_policy`);if(this.rulesPath=i(a,`rules.json`),e(a)||t(a,{recursive:!0}),e(this.rulesPath))try{let e=n(this.rulesPath,`utf-8`),t=JSON.parse(e);if(!Array.isArray(t))throw Error(`rules.json must be an array`);for(let e of t)if(typeof e!=`object`||!e||typeof e.id!=`string`||!Array.isArray(e.patterns)||typeof e.category!=`string`||typeof e.pushWeight!=`number`)throw Error(`Invalid rule: ${JSON.stringify(e).slice(0,100)}`);this.rules=t}catch{o.warn(`Failed to parse policy rules, resetting to starter set`),this.rules=[...c],this.save()}else this.rules=[...c],this.save()}classify(e,t,n){let r=`${e} ${t} ${n.join(` `)}`.toLowerCase(),i=[];for(let e of this.rules){if(!e.enabled)continue;let t=e.patterns.filter(e=>r.includes(e.toLowerCase()));t.length>0&&i.push({ruleId:e.id,category:e.category,pushWeight:e.pushWeight,matchedPatterns:t})}let a=i.length>0?Math.max(...i.map(e=>e.pushWeight)):0;return{matchingRules:i,pushRecommended:a>=.5,maxPushWeight:a}}getRules(){return[...this.rules]}getRule(e){return this.rules.find(t=>t.id===e)}updateRule(e,t){let n=this.rules.find(t=>t.id===e);if(n)return Object.assign(n,t,{updatedAt:new Date().toISOString(),autoPush:!1}),this.save(),n}addRule(e){if(this.rules.find(t=>t.id===e.id))throw Error(`Rule with id '${e.id}' already exists`);let t=new Date().toISOString(),n={...e,autoPush:!1,createdAt:t,updatedAt:t};return this.rules.push(n),this.save(),n}deleteRule(e){let t=this.rules.findIndex(t=>t.id===e);return t===-1?!1:(this.rules.splice(t,1),this.save(),!0)}save(){r(this.rulesPath,JSON.stringify(this.rules,null,2),`utf-8`)}};export{l as PolicyStore};

package/packages/enterprise-bridge/dist/push-adapter.d.ts

@@ -0,0 +1,23 @@
+import { ERPushRequest, ERPushResponse, ERSyncEntry } from "./types.js";
+import { ERClient } from "./er-client.js";
+
+//#region packages/enterprise-bridge/src/push-adapter.d.ts
+declare class PushAdapter {
+  private readonly client;
+  private readonly syncHistory;
+  private static readonly MAX_HISTORY;
+  constructor(client: ERClient);
+  /** Push a knowledge entry to ER */
+  push(entryId: string, request: ERPushRequest): Promise<ERPushResponse>;
+  /** Get sync history */
+  getHistory(): ERSyncEntry[];
+  /** Get sync status summary */
+  getStatus(): {
+    totalPushed: number;
+    successCount: number;
+    failCount: number;
+    lastPush?: ERSyncEntry;
+  };
+}
+//#endregion
+export { PushAdapter };

package/packages/enterprise-bridge/dist/push-adapter.js

@@ -0,0 +1 @@
+var e=class e{client;syncHistory=[];static MAX_HISTORY=100;constructor(e){this.client=e}async push(t,n){let r=await this.client.push(n);for(this.syncHistory.push({entryId:t,title:n.title,pushedAt:r.timestamp,status:r.status,remotePath:r.remotePath});this.syncHistory.length>e.MAX_HISTORY;)this.syncHistory.shift();return r}getHistory(){return[...this.syncHistory]}getStatus(){let e=this.syncHistory.filter(e=>e.status===`stored`).length;return{totalPushed:this.syncHistory.length,successCount:e,failCount:this.syncHistory.length-e,lastPush:this.syncHistory.at(-1)}}};export{e as PushAdapter};

package/packages/enterprise-bridge/dist/result-merger.d.ts

@@ -0,0 +1,14 @@
+import { ERSearchResult, MergedSearchResult } from "./types.js";
+import { SearchResult } from "@kb/core";
+
+//#region packages/enterprise-bridge/src/result-merger.d.ts
+/**
+ * Merge local and ER results using local-first interleaving.
+ *
+ * Local RRF scores (~0.01-0.05) and ER raw similarity scores (~0.3-0.9) are on
+ * incomparable scales. Instead of sorting both together (which would always rank
+ * ER above local), we preserve local ordering, deduplicate, then append ER results.
+ */
+declare function mergeResults(localResults: SearchResult[], erResults: ERSearchResult[], limit: number): MergedSearchResult[];
+//#endregion
+export { mergeResults };

package/packages/enterprise-bridge/dist/result-merger.js

@@ -0,0 +1 @@
+function e(e){return{content:e.record.content,sourcePath:e.record.sourcePath,score:e.score,source:`local`,startLine:e.record.startLine,endLine:e.record.endLine,contentType:e.record.contentType,headingPath:e.record.headingPath,origin:e.record.origin,category:e.record.category,tags:e.record.tags}}function t(e){return{content:e.content,sourcePath:e.sourcePath,score:e.score,source:`er`,metadata:e.metadata}}function n(e){return`${e.slice(0,200).replace(/\s+/g,` `)}:${e.length}`}function r(r,i,a){let o=new Set,s=[];for(let t of r){let r=n(t.record.content);o.has(r)||(o.add(r),s.push(e(t)))}let c=[...i].sort((e,t)=>t.score-e.score);for(let e of c){let r=n(e.content);o.has(r)||(o.add(r),s.push(t(e)))}return s.slice(0,a)}export{r as mergeResults};

package/packages/enterprise-bridge/dist/types.d.ts

@@ -0,0 +1,81 @@
+//#region packages/enterprise-bridge/src/types.d.ts
+/** ER bridge configuration (subset of KBConfig.er) */
+interface ERBridgeConfig {
+  enabled: boolean;
+  baseUrl: string;
+  apiKey: string;
+  timeoutMs: number;
+  cacheTtlMs: number;
+  cacheMaxEntries: number;
+  fallbackThreshold: number;
+}
+/** Result from ER search API */
+interface ERSearchResult {
+  content: string;
+  sourcePath: string;
+  score: number;
+  metadata?: Record<string, unknown>;
+}
+/** Response from ER search API (POST /api/v1/search) */
+interface ERSearchResponse {
+  sources: Array<{
+    content: string;
+    metadata: Record<string, string>;
+    score?: number;
+    confidence?: number;
+  }>;
+  query?: string;
+  searchMode?: string;
+}
+/** Push request to ER */
+interface ERPushRequest {
+  title: string;
+  content: string;
+  category?: string;
+  tags?: string[];
+}
+/** Push response from ER */
+interface ERPushResponse {
+  pushed: boolean;
+  status: 'stored' | 'failed';
+  remotePath?: string;
+  timestamp: string;
+  error?: string;
+}
+/** Transient ER error (429, 5xx, network) — retries exhausted but not a permanent failure */
+declare class ERTransientError extends Error {
+  readonly statusCode?: number | undefined;
+  constructor(message: string, statusCode?: number | undefined);
+}
+/** Sync status entry for tracking push history */
+interface ERSyncEntry {
+  entryId: string;
+  title: string;
+  pushedAt: string;
+  status: 'stored' | 'failed';
+  remotePath?: string;
+}
+/** Cache entry wrapping ER search results */
+interface ERCacheEntry {
+  results: ERSearchResult[];
+  query: string;
+  cachedAt: number;
+  ttl: number;
+}
+/** Merged search result with source provenance */
+interface MergedSearchResult {
+  content: string;
+  sourcePath: string;
+  score: number;
+  source: 'local' | 'er';
+  startLine?: number;
+  endLine?: number;
+  contentType?: string;
+  headingPath?: string;
+  origin?: string;
+  category?: string;
+  tags?: string[];
+  metadata?: Record<string, unknown>;
+}
+//#endregion
+export { ERBridgeConfig, ERCacheEntry, ERPushRequest, ERPushResponse, ERSearchResponse, ERSearchResult, ERSyncEntry, ERTransientError, MergedSearchResult };

package/packages/enterprise-bridge/dist/types.js

@@ -0,0 +1 @@
+var e=class extends Error{constructor(e,t){super(e),this.statusCode=t,this.name=`ERTransientError`}};export{e as ERTransientError};

package/packages/indexer/dist/file-hasher.d.ts

@@ -1,11 +1,13 @@
+//#region packages/indexer/src/file-hasher.d.ts
 /**
  * Generate a deterministic hash for a file's content.
  * Used for incremental indexing -- skip files that haven't changed.
  */
-export declare function hashContent(content: string): string;
+declare function hashContent(content: string): string;
 /**
  * Generate a deterministic ID for a knowledge record.
  * Based on source path + chunk index to ensure idempotent upserts.
  */
-export declare function generateRecordId(sourcePath: string, chunkIndex: number): string;
-//# sourceMappingURL=file-hasher.d.ts.map
+declare function generateRecordId(sourcePath: string, chunkIndex: number): string;
+//#endregion
+export { generateRecordId, hashContent };

package/packages/indexer/dist/file-hasher.js

@@ -1 +1 @@
-import{createHash as e}from"node:crypto";function i(t){return e("sha256").update(t).digest("hex").slice(0,16)}function o(t,n){const r=`${t}:${n}`;return e("sha256").update(r).digest("hex").slice(0,16)}export{o as generateRecordId,i as hashContent};
+import{createHash as e}from"node:crypto";function t(t){return e(`sha256`).update(t).digest(`hex`).slice(0,16)}function n(t,n){let r=`${t}:${n}`;return e(`sha256`).update(r).digest(`hex`).slice(0,16)}export{n as generateRecordId,t as hashContent};

package/packages/indexer/dist/filesystem-crawler.d.ts

@@ -1,27 +1,29 @@
-export interface CrawlResult {
-    /** File path relative to workspace root */
-    relativePath: string;
-    /** Absolute file path */
-    absolutePath: string;
-    /** File content */
-    content: string;
-    /** File extension (lowercase, with dot) */
-    extension: string;
+//#region packages/indexer/src/filesystem-crawler.d.ts
+interface CrawlResult {
+  /** File path relative to workspace root */
+  relativePath: string;
+  /** Absolute file path */
+  absolutePath: string;
+  /** File content */
+  content: string;
+  /** File extension (lowercase, with dot) */
+  extension: string;
 }
-export interface CrawlOptions {
-    /** Glob patterns to exclude */
-    excludePatterns: string[];
-    /** Root directory to crawl */
-    rootDir: string;
+interface CrawlOptions {
+  /** Glob patterns to exclude */
+  excludePatterns: string[];
+  /** Root directory to crawl */
+  rootDir: string;
 }
 /**
  * Crawl a directory tree and yield files that should be indexed.
  */
-export declare class FilesystemCrawler {
-    /** Binary file extensions that should always be skipped */
-    private static readonly BINARY_EXTENSIONS;
-    crawl(options: CrawlOptions): Promise<CrawlResult[]>;
-    private walkDir;
-    private isExcluded;
+declare class FilesystemCrawler {
+  /** Binary file extensions that should always be skipped */
+  private static readonly BINARY_EXTENSIONS;
+  crawl(options: CrawlOptions): Promise<CrawlResult[]>;
+  private walkDir;
+  private isExcluded;
 }
-//# sourceMappingURL=filesystem-crawler.d.ts.map
+//#endregion
+export { CrawlOptions, CrawlResult, FilesystemCrawler };

package/packages/indexer/dist/filesystem-crawler.js

@@ -1 +1 @@
-import{lstat as u,readdir as w,readFile as d,stat as g}from"node:fs/promises";import{extname as h,join as x,relative as S}from"node:path";import{FILE_LIMITS as y}from"../../core/dist/index.js";import{minimatch as E}from"minimatch";class p{static BINARY_EXTENSIONS=new Set([".node",".so",".dylib",".dll",".wasm",".bin",".exe",".png",".jpg",".jpeg",".gif",".bmp",".ico",".webp",".svg",".mp3",".mp4",".wav",".avi",".mov",".flac",".zip",".gz",".tar",".bz2",".7z",".rar",".pdf",".doc",".docx",".xls",".xlsx",".ppt",".pptx",".ttf",".otf",".woff",".woff2",".eot",".pyc",".class",".o",".obj",".a",".lib"]);async crawl(e){const i=[],n=new Set;return await this.walkDir(e.rootDir,e.rootDir,e.excludePatterns,i,n),i}async walkDir(e,i,n,s,o){let c;try{c=await w(e,{withFileTypes:!0})}catch(r){const t=r.code;(t==="EACCES"||t==="EPERM")&&console.error(`[KB] Permission denied, skipping directory: ${e}`);return}for(const r of c){const t=x(e,r.name),l=S(i,t).replace(/\\/g,"/");if(!this.isExcluded(l,n)){if(r.isDirectory()){if(r.name.startsWith("."))continue;try{if((await u(t)).isSymbolicLink())continue}catch{continue}const a=t;if(o.has(a))continue;o.add(a),await this.walkDir(t,i,n,s,o)}else if(r.isFile()){const a=h(r.name).toLowerCase();if(p.BINARY_EXTENSIONS.has(a))continue;try{if((await g(t)).size>y.maxFileSizeBytes)continue;const f=await d(t,"utf-8");if(f.includes("\0"))continue;s.push({relativePath:l,absolutePath:t,content:f,extension:a})}catch{}}}}}isExcluded(e,i){return i.some(n=>E(e,n,{dot:!0}))}}export{p as FilesystemCrawler};
+import{lstat as e,readFile as t,readdir as n,stat as r}from"node:fs/promises";import{extname as i,join as a,relative as o}from"node:path";import{FILE_LIMITS as s,KB_PATHS as c,createLogger as l}from"../../core/dist/index.js";import{minimatch as u}from"minimatch";const d=l(`indexer`);var f=class l{static BINARY_EXTENSIONS=new Set(`.node,.so,.dylib,.dll,.wasm,.bin,.exe,.png,.jpg,.jpeg,.gif,.bmp,.ico,.webp,.svg,.mp3,.mp4,.wav,.avi,.mov,.flac,.zip,.gz,.tar,.bz2,.7z,.rar,.pdf,.doc,.docx,.xls,.xlsx,.ppt,.pptx,.ttf,.otf,.woff,.woff2,.eot,.pyc,.class,.o,.obj,.a,.lib`.split(`,`));async crawl(e){let t=[],n=new Set;return await this.walkDir(e.rootDir,e.rootDir,e.excludePatterns,t,n),t}async walkDir(u,f,p,m,h){let g;try{g=await n(u,{withFileTypes:!0})}catch(e){let t=e.code;(t===`EACCES`||t===`EPERM`)&&d.warn(`Permission denied, skipping directory`,{dir:u});return}for(let n of g){let d=a(u,n.name),g=o(f,d).replace(/\\/g,`/`);if(!this.isExcluded(g,p)){if(n.isDirectory()){if(n.name.startsWith(`.`)&&!(n.name===c.ai.slice(1)&&g.startsWith(c.ai)))continue;try{if((await e(d)).isSymbolicLink())continue}catch{continue}let t=d;if(h.has(t))continue;h.add(t),await this.walkDir(d,f,p,m,h)}else if(n.isFile()){let e=i(n.name).toLowerCase();if(l.BINARY_EXTENSIONS.has(e))continue;try{if((await r(d)).size>s.maxFileSizeBytes)continue;let n=await t(d,`utf-8`);if(n.includes(`\0`))continue;m.push({relativePath:g,absolutePath:d,content:n,extension:e})}catch{}}}}}isExcluded(e,t){return t.some(t=>u(e,t,{dot:!0}))}};export{f as FilesystemCrawler};

package/packages/indexer/dist/graph-extractor.d.ts

@@ -1,14 +1,9 @@
-/**
- * Lightweight graph extraction for automatic population during indexing.
- * Extracts symbols (functions, classes, interfaces, etc.) and import relationships
- * from source code, producing GraphNode[] and GraphEdge[] for the graph store.
- *
- * Focuses on TS/JS — the primary use case. Non-code files return empty graphs.
- */
-import type { GraphEdge, GraphNode } from '@kb/store';
-export interface ExtractedGraph {
-    nodes: GraphNode[];
-    edges: GraphEdge[];
+import { GraphEdge, GraphNode } from "@kb/store";
+
+//#region packages/indexer/src/graph-extractor.d.ts
+interface ExtractedGraph {
+  nodes: GraphNode[];
+  edges: GraphEdge[];
 }
 /**
  * Extract graph nodes and edges from a single file's content.
@@ -18,5 +13,6 @@ export interface ExtractedGraph {
  * - "defines" edges from module → symbol
  * - "imports" edges from module → imported module
  */
-export declare function extractGraph(content: string, sourcePath: string): ExtractedGraph;
-//# sourceMappingURL=graph-extractor.d.ts.map
+declare function extractGraph(content: string, sourcePath: string): ExtractedGraph;
+//#endregion
+export { ExtractedGraph, extractGraph };

package/packages/indexer/dist/graph-extractor.js

@@ -1 +1 @@
-import{createHash as y}from"node:crypto";import{dirname as k,extname as j,join as I}from"node:path";const S=new Set([".ts",".tsx",".js",".jsx",".mjs",".cjs"]),$=[{pattern:/^export\s+(?:async\s+)?function\s+(\w+)/gm,kind:"function",exported:!0},{pattern:/^export\s+(?:default\s+)?class\s+(\w+)/gm,kind:"class",exported:!0},{pattern:/^export\s+interface\s+(\w+)/gm,kind:"interface",exported:!0},{pattern:/^export\s+type\s+(\w+)/gm,kind:"type",exported:!0},{pattern:/^export\s+(?:const|let)\s+(\w+)/gm,kind:"const",exported:!0},{pattern:/^export\s+enum\s+(\w+)/gm,kind:"enum",exported:!0},{pattern:/^(?:async\s+)?function\s+(\w+)/gm,kind:"function",exported:!1},{pattern:/^class\s+(\w+)/gm,kind:"class",exported:!1},{pattern:/^interface\s+(\w+)/gm,kind:"interface",exported:!1},{pattern:/^type\s+(\w+)/gm,kind:"type",exported:!1},{pattern:/^enum\s+(\w+)/gm,kind:"enum",exported:!1}],G=[/import\s+(?:(?:type\s+)?(?:(?:\{[^}]*\}|[\w*]+)\s+from\s+)?)['"]([^'"]+)['"]/g,/import\(\s*['"]([^'"]+)['"]\s*\)/g,/require\(\s*['"]([^'"]+)['"]\s*\)/g];function x(t,e,s){return y("sha256").update(`${t}:${e}:${s}`).digest("hex").slice(0,16)}function E(t,e,s){return y("sha256").update(`${t}-${s}-${e}`).digest("hex").slice(0,16)}function R(t,e){const s=k(e);return I(s,t).replace(/\\/g,"/").replace(/\.(js|jsx|ts|tsx|mjs|cjs)$/,"")}function N(t){return t.replace(/\.(js|jsx|ts|tsx|mjs|cjs)$/,"")}function O(t,e){const s=j(e).toLowerCase();if(!S.has(s))return{nodes:[],edges:[]};const c=[],g=[],l=new Date().toISOString(),u=new Set,f=N(e),o=x("module",f,f);c.push({id:o,type:"module",name:e,properties:{ext:s},sourcePath:e,createdAt:l});for(const{pattern:i,kind:p,exported:d}of $){const n=new RegExp(i.source,i.flags);let a;for(;(a=n.exec(t))!==null;){const r=a[1],h=`${p}:${r}`;if(u.has(h))continue;u.add(h);const m=x(p,r,e);c.push({id:m,type:p,name:r,properties:{exported:d},sourcePath:e,createdAt:l}),g.push({id:E(o,m,"defines"),fromId:o,toId:m,type:"defines",weight:d?1:.5})}}const w=new Set;for(const i of G){const p=new RegExp(i.source,i.flags);let d;for(;(d=p.exec(t))!==null;){const n=d[1];if(!n.startsWith(".")||w.has(n))continue;w.add(n);const a=R(n,e),r=x("module",a,a);g.push({id:E(o,r,"imports"),fromId:o,toId:r,type:"imports",properties:{source:n}})}}return{nodes:c,edges:g}}export{O as extractGraph};
+import{createHash as e}from"node:crypto";import{dirname as t,extname as n,join as r}from"node:path";const i=new Set([`.ts`,`.tsx`,`.js`,`.jsx`,`.mjs`,`.cjs`]),a=[{pattern:/^export\s+(?:async\s+)?function\s+(\w+)/gm,kind:`function`,exported:!0},{pattern:/^export\s+(?:default\s+)?class\s+(\w+)/gm,kind:`class`,exported:!0},{pattern:/^export\s+interface\s+(\w+)/gm,kind:`interface`,exported:!0},{pattern:/^export\s+type\s+(\w+)/gm,kind:`type`,exported:!0},{pattern:/^export\s+(?:const|let)\s+(\w+)/gm,kind:`const`,exported:!0},{pattern:/^export\s+enum\s+(\w+)/gm,kind:`enum`,exported:!0},{pattern:/^(?:async\s+)?function\s+(\w+)/gm,kind:`function`,exported:!1},{pattern:/^class\s+(\w+)/gm,kind:`class`,exported:!1},{pattern:/^interface\s+(\w+)/gm,kind:`interface`,exported:!1},{pattern:/^type\s+(\w+)/gm,kind:`type`,exported:!1},{pattern:/^enum\s+(\w+)/gm,kind:`enum`,exported:!1}],o=[/import\s+(?:(?:type\s+)?(?:(?:\{[^}]*\}|[\w*]+)\s+from\s+)?)['"]([^'"]+)['"]/g,/import\(\s*['"]([^'"]+)['"]\s*\)/g,/require\(\s*['"]([^'"]+)['"]\s*\)/g];function s(t,n,r){return e(`sha256`).update(`${t}:${n}:${r}`).digest(`hex`).slice(0,16)}function c(t,n,r){return e(`sha256`).update(`${t}-${r}-${n}`).digest(`hex`).slice(0,16)}function l(e,n){return r(t(n),e).replace(/\\/g,`/`).replace(/\.(js|jsx|ts|tsx|mjs|cjs)$/,``)}function u(e){return e.replace(/\.(js|jsx|ts|tsx|mjs|cjs)$/,``)}function d(e,t){let r=n(t).toLowerCase();if(!i.has(r))return{nodes:[],edges:[]};let d=[],f=[],p=new Date().toISOString(),m=new Set,h=u(t),g=s(`module`,h,h);d.push({id:g,type:`module`,name:t,properties:{ext:r},sourcePath:t,createdAt:p});for(let{pattern:n,kind:r,exported:i}of a){let a=new RegExp(n.source,n.flags),o;for(;(o=a.exec(e))!==null;){let e=o[1],n=`${r}:${e}`;if(m.has(n))continue;m.add(n);let a=s(r,e,t);d.push({id:a,type:r,name:e,properties:{exported:i},sourcePath:t,createdAt:p}),f.push({id:c(g,a,`defines`),fromId:g,toId:a,type:`defines`,weight:i?1:.5})}}let _=new Set;for(let n of o){let r=new RegExp(n.source,n.flags),i;for(;(i=r.exec(e))!==null;){let e=i[1];if(!e.startsWith(`.`)||_.has(e))continue;_.add(e);let n=l(e,t),r=s(`module`,n,n);f.push({id:c(g,r,`imports`),fromId:g,toId:r,type:`imports`,properties:{source:e}})}}return{nodes:d,edges:f}}export{d as extractGraph};