@vpxa/kb 0.1.12 → 0.1.15

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

@@ -0,0 +1,38 @@
+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 };
+//# sourceMappingURL=er-client.d.ts.map

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

@@ -0,0 +1,2 @@
+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};
+//# sourceMappingURL=er-client.js.map

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

@@ -0,0 +1,63 @@
+//#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 };
+//# sourceMappingURL=evolution-collector.d.ts.map

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

@@ -0,0 +1,2 @@
+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};
+//# sourceMappingURL=evolution-collector.js.map

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,46 @@
+//#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 };
+//# sourceMappingURL=policy-store.d.ts.map

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

@@ -0,0 +1,2 @@
+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};
+//# sourceMappingURL=policy-store.js.map

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

@@ -0,0 +1,24 @@
+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 };
+//# sourceMappingURL=push-adapter.d.ts.map

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

@@ -0,0 +1,2 @@
+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};
+//# sourceMappingURL=push-adapter.js.map

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

@@ -0,0 +1,15 @@
+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 };
+//# sourceMappingURL=result-merger.d.ts.map

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

@@ -0,0 +1,2 @@
+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};
+//# sourceMappingURL=result-merger.js.map

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

@@ -0,0 +1,82 @@
+//#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 };
+//# sourceMappingURL=types.d.ts.map

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

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

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

@@ -1,11 +1,14 @@
+//#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;
+declare function generateRecordId(sourcePath: string, chunkIndex: number): string;
+//#endregion
+export { generateRecordId, hashContent };
 //# sourceMappingURL=file-hasher.d.ts.map

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

@@ -1 +1,2 @@
-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};
+//# sourceMappingURL=file-hasher.js.map

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

@@ -1,27 +1,30 @@
-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;
 }
+//#endregion
+export { CrawlOptions, CrawlResult, FilesystemCrawler };
 //# sourceMappingURL=filesystem-crawler.d.ts.map

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

@@ -1 +1,2 @@
-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,createLogger as c}from"../../core/dist/index.js";import{minimatch as l}from"minimatch";const u=c(`indexer`);var d=class c{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(l,d,f,p,m){let h;try{h=await n(l,{withFileTypes:!0})}catch(e){let t=e.code;(t===`EACCES`||t===`EPERM`)&&u.warn(`Permission denied, skipping directory`,{dir:l});return}for(let n of h){let u=a(l,n.name),h=o(d,u).replace(/\\/g,`/`);if(!this.isExcluded(h,f)){if(n.isDirectory()){if(n.name.startsWith(`.`))continue;try{if((await e(u)).isSymbolicLink())continue}catch{continue}let t=u;if(m.has(t))continue;m.add(t),await this.walkDir(u,d,f,p,m)}else if(n.isFile()){let e=i(n.name).toLowerCase();if(c.BINARY_EXTENSIONS.has(e))continue;try{if((await r(u)).size>s.maxFileSizeBytes)continue;let n=await t(u,`utf-8`);if(n.includes(`\0`))continue;p.push({relativePath:h,absolutePath:u,content:n,extension:e})}catch{}}}}}isExcluded(e,t){return t.some(t=>l(e,t,{dot:!0}))}};export{d as FilesystemCrawler};
+//# sourceMappingURL=filesystem-crawler.js.map

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,7 @@ export interface ExtractedGraph {
  * - "defines" edges from module → symbol
  * - "imports" edges from module → imported module
  */
-export declare function extractGraph(content: string, sourcePath: string): ExtractedGraph;
+declare function extractGraph(content: string, sourcePath: string): ExtractedGraph;
+//#endregion
+export { ExtractedGraph, extractGraph };
 //# sourceMappingURL=graph-extractor.d.ts.map

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

@@ -1 +1,2 @@
-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};
+//# sourceMappingURL=graph-extractor.js.map

package/packages/indexer/dist/incremental-indexer.d.ts

@@ -1,47 +1,53 @@
-import type { IndexStats, KBConfig } from '@kb/core';
-import type { IEmbedder } from '@kb/embeddings';
-import type { IGraphStore, IKnowledgeStore } from '@kb/store';
-export interface IndexProgress {
-    phase: 'crawling' | 'chunking' | 'embedding' | 'storing' | 'cleanup' | 'done';
-    filesTotal: number;
-    filesProcessed: number;
-    chunksTotal: number;
-    chunksProcessed: number;
-    /** The file currently being processed */
-    currentFile?: string;
+import { IGraphStore, IKnowledgeStore } from "@kb/store";
+import { IndexStats, KBConfig } from "@kb/core";
+import { IEmbedder } from "@kb/embeddings";
+
+//#region packages/indexer/src/incremental-indexer.d.ts
+interface IndexProgress {
+  phase: 'crawling' | 'chunking' | 'embedding' | 'storing' | 'cleanup' | 'done';
+  filesTotal: number;
+  filesProcessed: number;
+  chunksTotal: number;
+  chunksProcessed: number;
+  /** The file currently being processed */
+  currentFile?: string;
 }
-export type ProgressCallback = (progress: IndexProgress) => void;
-export interface IndexResult {
-    filesProcessed: number;
-    filesSkipped: number;
-    chunksCreated: number;
-    filesRemoved: number;
-    durationMs: number;
+type ProgressCallback = (progress: IndexProgress) => void;
+interface IndexResult {
+  filesProcessed: number;
+  filesSkipped: number;
+  chunksCreated: number;
+  filesRemoved: number;
+  durationMs: number;
 }
-export declare class IncrementalIndexer {
-    private readonly embedder;
-    private readonly store;
-    private readonly crawler;
-    private indexing;
-    private graphStore?;
-    constructor(embedder: IEmbedder, store: IKnowledgeStore);
-    /** Set the graph store for auto-population during indexing and cleanup on re-index. */
-    setGraphStore(graphStore: IGraphStore): void;
-    /**
-     * Index all configured sources. Only re-indexes files that have changed.
-     * Sources are crawled in parallel, and file processing runs concurrently
-     * up to `config.indexing.concurrency` (default: half of CPU cores).
-     */
-    index(config: KBConfig, onProgress?: ProgressCallback): Promise<IndexResult>;
-    private doIndex;
-    /**
-     * Force re-index all files (ignoring hashes).
-     */
-    reindexAll(config: KBConfig, onProgress?: ProgressCallback): Promise<IndexResult>;
-    private doReindex;
-    /**
-     * Get current index statistics.
-     */
-    getStats(): Promise<IndexStats>;
+declare class IncrementalIndexer {
+  private readonly embedder;
+  private readonly store;
+  private readonly crawler;
+  private indexing;
+  private graphStore?;
+  /** Whether an index operation is currently in progress. */
+  get isIndexing(): boolean;
+  constructor(embedder: IEmbedder, store: IKnowledgeStore);
+  /** Set the graph store for auto-population during indexing and cleanup on re-index. */
+  setGraphStore(graphStore: IGraphStore): void;
+  /**
+   * Index all configured sources. Only re-indexes files that have changed.
+   * Sources are crawled in parallel, and file processing runs concurrently
+   * up to `config.indexing.concurrency` (default: half of CPU cores).
+   */
+  index(config: KBConfig, onProgress?: ProgressCallback): Promise<IndexResult>;
+  private doIndex;
+  /**
+   * Force re-index all files (ignoring hashes).
+   */
+  reindexAll(config: KBConfig, onProgress?: ProgressCallback): Promise<IndexResult>;
+  private doReindex;
+  /**
+   * Get current index statistics.
+   */
+  getStats(): Promise<IndexStats>;
 }
+//#endregion
+export { IncrementalIndexer, IndexProgress, IndexResult, ProgressCallback };
 //# sourceMappingURL=incremental-indexer.d.ts.map

package/packages/indexer/dist/incremental-indexer.js

@@ -1 +1,2 @@
-import{availableParallelism as G}from"node:os";import{createChunker as F}from"../../chunker/dist/index.js";import{detectContentType as B}from"../../core/dist/index.js";import{generateRecordId as K,hashContent as I}from"./file-hasher.js";import{FilesystemCrawler as H}from"./filesystem-crawler.js";import{extractGraph as A}from"./graph-extractor.js";async function S(c,s,r,o){let g=0;async function l(){for(;g<c.length;){const d=g++;try{await s(c[d])}catch(a){o?.(c[d],a)}}}await Promise.all(Array.from({length:Math.min(r,c.length)},()=>l()))}const L=Math.max(1,Math.floor(G()/2));class O{constructor(s,r){this.embedder=s;this.store=r;this.crawler=new H}crawler;indexing=!1;graphStore;setGraphStore(s){this.graphStore=s}async index(s,r){if(this.indexing)throw new Error("Indexing is already in progress");this.indexing=!0;try{return await this.doIndex(s,r,{})}finally{this.indexing=!1}}async doIndex(s,r,o={}){const g=Date.now();let l=0,d=0,a=0,C=0;const w=s.indexing.concurrency??L;r?.({phase:"crawling",filesTotal:0,filesProcessed:0,chunksTotal:0,chunksProcessed:0});const y=(await Promise.all(s.sources.map(e=>this.crawler.crawl({rootDir:e.path,excludePatterns:e.excludePatterns})))).flat();let p,f;if(o.skipHashCheck)p=y,f=[];else{const e=await this.store.listSourcePaths(),h=new Set(y.map(n=>n.relativePath));f=e.filter(n=>!h.has(n)&&!n.startsWith("curated/")),p=[],await S(y,async n=>{const i=I(n.content),P=await this.store.getBySourcePath(n.relativePath);if(P.length>0&&P[0].fileHash===i){d++;return}p.push(n)},w,(n,i)=>console.error(`[indexer] hash check failed for ${n.relativePath}:`,i))}const u=p.length,b=50;let m=[],x=[],k=0;const v=async()=>{if(this.graphStore){try{m.length>0&&await this.graphStore.upsertNodes(m),x.length>0&&await this.graphStore.upsertEdges(x)}catch(e){console.error("[indexer] graph batch flush failed:",e)}m=[],x=[],k=0}};return await S(p,async e=>{r?.({phase:"chunking",filesTotal:u,filesProcessed:l,chunksTotal:a,chunksProcessed:a,currentFile:e.relativePath});const h=B(e.relativePath),i=F(e.extension).chunk(e.content,{sourcePath:e.relativePath,contentType:h});if(i.length===0)return;r?.({phase:"embedding",filesTotal:u,filesProcessed:l,chunksTotal:a+i.length,chunksProcessed:a,currentFile:e.relativePath});const P=await this.embedder.embedBatch(i.map(t=>t.text)),T=I(e.content),R=i.map((t,E)=>({id:K(e.relativePath,E),content:t.text,sourcePath:t.sourcePath,contentType:t.contentType,headingPath:t.headingPath,chunkIndex:t.chunkIndex,totalChunks:t.totalChunks,startLine:t.startLine,endLine:t.endLine,fileHash:T,indexedAt:new Date().toISOString(),origin:"indexed",tags:[],version:1}));if(r?.({phase:"storing",filesTotal:u,filesProcessed:l,chunksTotal:a+i.length,chunksProcessed:a,currentFile:e.relativePath}),await this.store.upsert(R,P),this.graphStore)try{o.graphCleared||await this.graphStore.deleteBySourcePath(e.relativePath);const t=A(e.content,e.relativePath);t.nodes.length>0&&m.push(...t.nodes),t.edges.length>0&&x.push(...t.edges),k++,k>=b&&await v()}catch(t){console.error(`[indexer] graph extraction failed for ${e.relativePath}:`,t)}l++,a+=i.length},w,(e,h)=>console.error(`[indexer] processing failed for ${e.relativePath}:`,h)),await v(),f.length>0&&(r?.({phase:"cleanup",filesTotal:u,filesProcessed:l,chunksTotal:a,chunksProcessed:a}),await S(f,async e=>{await this.store.deleteBySourcePath(e),this.graphStore&&await this.graphStore.deleteBySourcePath(e).catch(h=>console.error(`[indexer] graph cleanup failed for ${e}:`,h)),C++},w,(e,h)=>console.error(`[indexer] cleanup failed for ${e}:`,h))),r?.({phase:"done",filesTotal:u,filesProcessed:l,chunksTotal:a,chunksProcessed:a}),{filesProcessed:l,filesSkipped:d,chunksCreated:a,filesRemoved:C,durationMs:Date.now()-g}}async reindexAll(s,r){if(await this.store.dropTable(),this.graphStore)try{const o=await this.graphStore.getStats();o.nodeCount>0&&(await this.graphStore.clear(),console.error(`[indexer] Graph store cleared (was ${o.nodeCount} nodes, ${o.edgeCount} edges)`))}catch(o){console.error("[indexer] Graph store clear failed:",o)}return this.doReindex(s,r)}async doReindex(s,r){if(this.indexing)throw new Error("Indexing is already in progress");this.indexing=!0;try{return await this.doIndex(s,r,{skipHashCheck:!0,graphCleared:!0})}finally{this.indexing=!1}}async getStats(){return this.store.getStats()}}export{O as IncrementalIndexer};
+import{generateRecordId as e,hashContent as t}from"./file-hasher.js";import{FilesystemCrawler as n}from"./filesystem-crawler.js";import{extractGraph as r}from"./graph-extractor.js";import{createLogger as i,detectContentType as a,serializeError as o}from"../../core/dist/index.js";import{availableParallelism as s}from"node:os";import{createChunker as c}from"../../chunker/dist/index.js";const l=i(`indexer`);async function u(e,t,n,r){let i=0;async function a(){for(;i<e.length;){let n=i++;try{await t(e[n])}catch(t){r?.(e[n],t)}}}await Promise.all(Array.from({length:Math.min(n,e.length)},()=>a()))}const d=Math.max(1,Math.floor(s()/2));var f=class{crawler;indexing=!1;graphStore;get isIndexing(){return this.indexing}constructor(e,t){this.embedder=e,this.store=t,this.crawler=new n}setGraphStore(e){this.graphStore=e}async index(e,t){if(this.indexing)throw Error(`Indexing is already in progress`);this.indexing=!0;try{return await this.doIndex(e,t,{})}finally{this.indexing=!1}}async doIndex(n,i,s={}){let f=Date.now(),p=0,m=0,h=0,g=0,_=n.indexing.concurrency??d;i?.({phase:`crawling`,filesTotal:0,filesProcessed:0,chunksTotal:0,chunksProcessed:0});let v=(await Promise.all(n.sources.map(e=>this.crawler.crawl({rootDir:e.path,excludePatterns:e.excludePatterns})))).flat(),y,b;if(s.skipHashCheck)y=v,b=[];else{let e=await this.store.listSourcePaths(),n=new Set(v.map(e=>e.relativePath));b=e.filter(e=>!n.has(e)&&!e.startsWith(`curated/`)),y=[],await u(v,async e=>{let n=t(e.content),r=await this.store.getBySourcePath(e.relativePath);if(r.length>0&&r[0].fileHash===n){m++;return}y.push(e)},_,(e,t)=>l.error(`Hash check failed`,{sourcePath:e.relativePath,...o(t)}))}let x=y.length,S=[],C=[],w=0,T=async()=>{if(this.graphStore){try{S.length>0&&await this.graphStore.upsertNodes(S),C.length>0&&await this.graphStore.upsertEdges(C)}catch(e){l.warn(`Graph batch flush failed`,o(e))}S=[],C=[],w=0}};return await u(y,async n=>{i?.({phase:`chunking`,filesTotal:x,filesProcessed:p,chunksTotal:h,chunksProcessed:h,currentFile:n.relativePath});let u=a(n.relativePath),d=c(n.extension).chunk(n.content,{sourcePath:n.relativePath,contentType:u});if(d.length===0)return;i?.({phase:`embedding`,filesTotal:x,filesProcessed:p,chunksTotal:h+d.length,chunksProcessed:h,currentFile:n.relativePath});let f=await this.embedder.embedBatch(d.map(e=>e.text)),m=t(n.content),g=d.map((t,r)=>({id:e(n.relativePath,r),content:t.text,sourcePath:t.sourcePath,contentType:t.contentType,headingPath:t.headingPath,chunkIndex:t.chunkIndex,totalChunks:t.totalChunks,startLine:t.startLine,endLine:t.endLine,fileHash:m,indexedAt:new Date().toISOString(),origin:`indexed`,tags:[],version:1}));if(i?.({phase:`storing`,filesTotal:x,filesProcessed:p,chunksTotal:h+d.length,chunksProcessed:h,currentFile:n.relativePath}),await this.store.upsert(g,f),this.graphStore)try{s.graphCleared||await this.graphStore.deleteBySourcePath(n.relativePath);let e=r(n.content,n.relativePath);e.nodes.length>0&&S.push(...e.nodes),e.edges.length>0&&C.push(...e.edges),w++,w>=50&&await T()}catch(e){l.warn(`Graph extraction failed`,{sourcePath:n.relativePath,...o(e)})}p++,h+=d.length},_,(e,t)=>l.error(`Processing failed`,{sourcePath:e.relativePath,...o(t)})),await T(),b.length>0&&(i?.({phase:`cleanup`,filesTotal:x,filesProcessed:p,chunksTotal:h,chunksProcessed:h}),await u(b,async e=>{await this.store.deleteBySourcePath(e),this.graphStore&&await this.graphStore.deleteBySourcePath(e).catch(t=>l.warn(`Graph cleanup failed`,{sourcePath:e,...o(t)})),g++},_,(e,t)=>l.error(`Cleanup failed`,{sourcePath:e,...o(t)}))),i?.({phase:`done`,filesTotal:x,filesProcessed:p,chunksTotal:h,chunksProcessed:h}),{filesProcessed:p,filesSkipped:m,chunksCreated:h,filesRemoved:g,durationMs:Date.now()-f}}async reindexAll(e,t){if(this.indexing)throw Error(`Indexing is already in progress`);this.indexing=!0;try{if(await this.store.dropTable(),this.graphStore)try{let e=await this.graphStore.getStats();e.nodeCount>0&&(await this.graphStore.clear(),l.info(`Graph store cleared`,{nodeCount:e.nodeCount,edgeCount:e.edgeCount}))}catch(e){l.warn(`Graph store clear failed`,o(e))}return await this.doReindex(e,t)}catch(e){throw this.indexing=!1,e}}async doReindex(e,t){try{return await this.doIndex(e,t,{skipHashCheck:!0,graphCleared:!0})}finally{this.indexing=!1}}async getStats(){return this.store.getStats()}};export{f as IncrementalIndexer};
+//# sourceMappingURL=incremental-indexer.js.map