@vpxa/aikit 0.1.1

package/packages/server/dist/api.d.ts

@@ -0,0 +1,3 @@
+import { loadConfig } from "./config.js";
+import { KnowledgeBaseComponents, createMcpServer, createServer, initializeKnowledgeBase } from "./server.js";
+export { type KnowledgeBaseComponents, createMcpServer, createServer, initializeKnowledgeBase, loadConfig };

package/packages/server/dist/api.js

@@ -0,0 +1 @@
+import{loadConfig as e}from"./config.js";import{createMcpServer as t,createServer as n,initializeKnowledgeBase as r}from"./server.js";export{t as createMcpServer,n as createServer,r as initializeKnowledgeBase,e as loadConfig};

package/packages/server/dist/auto-gc.d.ts

@@ -0,0 +1,30 @@
+//#region packages/server/src/auto-gc.d.ts
+/**
+ * P1-13: Self-tuning garbage collection based on p95 latency.
+ *
+ * Monitors tool call latency via the replay-interceptor's rolling buffer.
+ * When p95 exceeds a threshold the system enters "degraded" state and
+ * triggers progressive GC actions. A cooldown period prevents over-collection.
+ */
+type GcState = 'healthy' | 'warming' | 'degraded';
+interface GcStatus {
+  state: GcState;
+  p95: number;
+  lastGcAt: number | null;
+  gcCount: number;
+  bufferSize: number;
+}
+type GcCallback = () => Promise<void>;
+/**
+ * Evaluate the current latency profile and optionally trigger GC.
+ *
+ * Call this periodically (e.g. every N tool calls) from the replay interceptor.
+ * The optional `gcCallback` receives control when a GC cycle is triggered —
+ * the caller decides *what* to clean up (pruning stale curated entries,
+ * vacuuming SQLite, removing orphaned graph nodes, etc.).
+ */
+declare function checkAndMaybeGc(gcCallback?: GcCallback): void;
+/** Return a snapshot of the GC health state for the status tool. */
+declare function getGcStatus(): GcStatus;
+//#endregion
+export { GcCallback, checkAndMaybeGc, getGcStatus };

package/packages/server/dist/auto-gc.js

@@ -0,0 +1 @@
+import{getLatencyBuffer as e}from"./replay-interceptor.js";import{createLogger as t}from"../../core/dist/index.js";const n=t(`auto-gc`);let r=`warming`,i=null,a=0;function o(){let t=[...e()];if(t.length<10)return 0;t.sort((e,t)=>e-t);let n=Math.floor(t.length*.95);return t[Math.min(n,t.length-1)]}function s(e){let t=o();if(t===0){r=`warming`;return}if(t>500){r=`degraded`;let o=Date.now();if(i&&o-i<36e5){n.debug(`GC cooldown active — skipping`,{lastGcAgoMs:o-i});return}i=o,a++,n.warn(`p95 latency exceeds threshold, triggering GC`,{p95:t,cycle:a}),e&&e().catch(e=>n.error(`GC callback failed`,{err:String(e)}))}else t<200&&(r=`healthy`)}function c(){return{state:r,p95:o(),lastGcAt:i,gcCount:a,bufferSize:e().length}}export{s as checkAndMaybeGc,c as getGcStatus};

package/packages/server/dist/completions.d.ts

@@ -0,0 +1,14 @@
+import { CuratedKnowledgeManager } from "./curated-manager.js";
+import { IGraphStore, IKnowledgeStore } from "../../store/dist/index.js";
+
+//#region packages/server/src/completions.d.ts
+/** Clear all completion caches (useful for testing). */
+declare function clearCompletionCache(): void;
+declare function completeCuratedPaths(curated: CuratedKnowledgeManager, partial: string): Promise<string[]>;
+declare function completeFilePaths(store: IKnowledgeStore, partial: string): Promise<string[]>;
+declare function completeSymbolNames(graphStore: IGraphStore, partial: string): Promise<string[]>;
+declare function completeStashKeys(partial: string): string[];
+declare function completeWorksetNames(partial: string): string[];
+declare function completeCheckpointNames(partial: string): string[];
+//#endregion
+export { clearCompletionCache, completeCheckpointNames, completeCuratedPaths, completeFilePaths, completeStashKeys, completeSymbolNames, completeWorksetNames };

package/packages/server/dist/completions.js

@@ -0,0 +1 @@
+import{checkpointList as e,listWorksets as t,stashList as n}from"../../tools/dist/index.js";const r=3e4,i=new Map;function a(e,t,n){let r=i.get(e);if(r&&Date.now()<r.expires)return Promise.resolve(r.data);let a=n();return Promise.resolve(a).then(n=>(i.set(e,{data:n,expires:Date.now()+t}),n))}function o(){i.clear()}function s(e,t){return a(`curated-paths`,r,async()=>(await e.list()).map(e=>e.path)).then(e=>e.filter(e=>e.toLowerCase().includes(t.toLowerCase())).slice(0,20))}function c(e,t){return a(`file-paths`,r,()=>e.listSourcePaths()).then(e=>e.filter(e=>e.toLowerCase().includes(t.toLowerCase())).slice(0,20))}function l(e,t){return a(`symbol-names`,r,async()=>(await e.findNodes({type:`symbol`,limit:500})).map(e=>e.name)).then(e=>e.filter(e=>e.toLowerCase().includes(t.toLowerCase())).slice(0,20))}function u(e){return n().map(e=>e.key).filter(t=>t.toLowerCase().includes(e.toLowerCase())).slice(0,20)}function d(e){return t().map(e=>e.name).filter(t=>t.toLowerCase().includes(e.toLowerCase())).slice(0,20)}function f(t){return e().map(e=>e.label).filter(e=>e.toLowerCase().includes(t.toLowerCase())).slice(0,20)}export{o as clearCompletionCache,f as completeCheckpointNames,s as completeCuratedPaths,c as completeFilePaths,u as completeStashKeys,l as completeSymbolNames,d as completeWorksetNames};

package/packages/server/dist/config.d.ts

@@ -0,0 +1,14 @@
+import { KBConfig } from "../../core/dist/index.js";
+
+//#region packages/server/src/config.d.ts
+declare function loadConfig(): KBConfig;
+/**
+ * Re-target an existing config to a new workspace root.
+ *
+ * Called after MCP roots are resolved — the initial config was built with
+ * `process.cwd()` (unknown at user-level), so we re-point source paths,
+ * store path, and curated path to the actual workspace the IDE has open.
+ */
+declare function reconfigureForWorkspace(config: KBConfig, workspaceRoot: string): void;
+//#endregion
+export { loadConfig, reconfigureForWorkspace };

package/packages/server/dist/config.js

@@ -0,0 +1 @@
+import{existsSync as e,readFileSync as t}from"node:fs";import{dirname as n,resolve as r}from"node:path";import{fileURLToPath as i}from"node:url";import{AIKIT_PATHS as a,createLogger as o,getPartitionDir as s,isUserInstalled as c,registerWorkspace as l,serializeError as u}from"../../core/dist/index.js";const d=n(i(import.meta.url)),f=o(`server`);function p(e,t,n){let i=r(e),a=r(t);if(!i.startsWith(a))throw Error(`Config ${n} path escapes workspace root: ${e} is not under ${t}`);return i}function m(){let i=process.env.AIKIT_CONFIG_PATH??(e(r(process.cwd(),`kb.config.json`))?r(process.cwd(),`kb.config.json`):r(d,`..`,`..`,`..`,`kb.config.json`));try{if(!e(i))return f.info(`No config file found, using defaults`,{configPath:i}),h();let o=t(i,`utf-8`),s=JSON.parse(o);if(!s.sources||!Array.isArray(s.sources)||s.sources.length===0)throw Error(`Config must have at least one source`);if(!s.store?.path)throw Error(`Config must specify store.path`);let c=n(i);return s.sources=s.sources.map(e=>({...e,path:p(r(c,e.path),c,`source`)})),s.store.path=p(r(c,s.store.path),c,`store`),s.curated=s.curated??{path:a.aiCurated},s.curated.path=p(r(c,s.curated.path),c,`curated`),g(s,c),s}catch(e){return f.error(`Failed to load config`,{configPath:i,...u(e)}),f.warn(`Falling back to default configuration`,{configPath:i}),h()}}function h(){let e=process.env.AIKIT_WORKSPACE_ROOT??process.cwd(),t={sources:[{path:e,excludePatterns:[`node_modules/**`,`dist/**`,`.git/**`,`coverage/**`,`*.lock`,`pnpm-lock.yaml`]}],serverName:`knowledge-base`,indexing:{chunkSize:1500,chunkOverlap:200,minChunkSize:100},embedding:{model:`mixedbread-ai/mxbai-embed-large-v1`,dimensions:1024},store:{backend:`lancedb`,path:r(e,a.data)},curated:{path:r(e,a.aiCurated)},onboardDir:r(e,a.aiKb)};return g(t,e),t}function g(e,t){if(!c())return;let n=t,i=l(n);e.store.path=r(s(i.partition)),e.onboardDir=r(s(i.partition),`onboard`),e.curated||={path:r(n,a.aiCurated)}}function _(e,t){f.info(`Reconfiguring for workspace root`,{workspaceRoot:t});try{process.chdir(t),f.info(`Changed process cwd to workspace root`,{cwd:process.cwd()})}catch(e){f.warn(`Failed to chdir to workspace root`,{workspaceRoot:t,...u(e)})}e.sources=[{path:t,excludePatterns:e.sources[0]?.excludePatterns??[`node_modules/**`,`dist/**`,`.git/**`,`coverage/**`,`*.lock`,`pnpm-lock.yaml`]}],e.store.path=r(t,a.data),e.curated={path:r(t,a.aiCurated)},e.onboardDir=r(t,a.aiKb),g(e,t)}export{m as loadConfig,_ as reconfigureForWorkspace};

package/packages/server/dist/cross-workspace.d.ts

@@ -0,0 +1,43 @@
+import { RegistryEntry, SearchResult } from "../../core/dist/index.js";
+import { IKnowledgeStore, SearchOptions } from "../../store/dist/index.js";
+
+//#region packages/server/src/cross-workspace.d.ts
+interface CrossWorkspaceOptions {
+  /** Workspace partition names or folder basenames to include. `"*"` means all. */
+  workspaces: string[];
+  /** Current workspace partition (excluded from cross-workspace queries to avoid double results) */
+  currentPartition?: string;
+}
+/**
+ * Resolve workspace identifiers to partition entries.
+ * Accepts partition keys (exact) or folder basenames (fuzzy match).
+ * Special value `"*"` resolves to all registered workspaces.
+ */
+declare function resolveWorkspaces(identifiers: string[], currentPartition?: string): RegistryEntry[];
+/**
+ * Open temporary read-only store instances for the specified workspace partitions.
+ * Caller MUST call closeAll() when done.
+ */
+declare function openWorkspaceStores(entries: RegistryEntry[]): Promise<{
+  stores: Map<string, IKnowledgeStore>;
+  closeAll: () => Promise<void>;
+}>;
+/**
+ * Fan-out a vector search to multiple workspace stores in parallel.
+ * Returns merged results sorted by score descending, with workspace labels.
+ */
+declare function fanOutSearch(stores: Map<string, IKnowledgeStore>, queryVector: Float32Array, options: SearchOptions & {
+  limit: number;
+}): Promise<Array<SearchResult & {
+  workspace: string;
+}>>;
+/**
+ * Fan-out a full-text search to multiple workspace stores in parallel.
+ */
+declare function fanOutFtsSearch(stores: Map<string, IKnowledgeStore>, query: string, options: SearchOptions & {
+  limit: number;
+}): Promise<Array<SearchResult & {
+  workspace: string;
+}>>;
+//#endregion
+export { CrossWorkspaceOptions, fanOutFtsSearch, fanOutSearch, openWorkspaceStores, resolveWorkspaces };

package/packages/server/dist/cross-workspace.js

@@ -0,0 +1 @@
+import{createLogger as e,getPartitionDir as t,isUserInstalled as n,listWorkspaces as r}from"../../core/dist/index.js";import{createStore as i}from"../../store/dist/index.js";const a=e(`cross-workspace`);function o(e,t){if(!n())return[];let i=r();if(i.length===0)return[];if(e.includes(`*`))return t?i.filter(e=>e.partition!==t):i;let a=[];for(let n of e){let e=i.find(e=>e.partition===n);if(e){e.partition!==t&&a.push(e);continue}let r=i.filter(e=>e.partition!==t&&e.partition.replace(/-[a-f0-9]{8}$/,``)===n.toLowerCase());a.push(...r)}let o=new Set;return a.filter(e=>o.has(e.partition)?!1:(o.add(e.partition),!0))}async function s(e){let n=new Map;for(let r of e)try{let e=await i({backend:`lancedb`,path:t(r.partition)});await e.initialize(),n.set(r.partition,e)}catch(e){a.warn(`Failed to open workspace store`,{partition:r.partition,err:e})}return{stores:n,closeAll:async()=>{for(let[,e]of n)try{await e.close()}catch{}}}}async function c(e,t,n){let r=[...e.entries()].map(async([e,r])=>{try{return(await r.search(t,n)).map(t=>({...t,workspace:e}))}catch(t){return a.warn(`Cross-workspace search failed for partition`,{partition:e,err:t}),[]}});return(await Promise.all(r)).flat().sort((e,t)=>t.score-e.score).slice(0,n.limit)}async function l(e,t,n){let r=[...e.entries()].map(async([e,r])=>{try{return(await r.ftsSearch(t,n)).map(t=>({...t,workspace:e}))}catch(t){return a.warn(`Cross-workspace FTS search failed for partition`,{partition:e,err:t}),[]}});return(await Promise.all(r)).flat().sort((e,t)=>t.score-e.score).slice(0,n.limit)}export{l as fanOutFtsSearch,c as fanOutSearch,s as openWorkspaceStores,o as resolveWorkspaces};

package/packages/server/dist/curated-manager.d.ts

@@ -0,0 +1,92 @@
+import { IEmbedder } from "../../embeddings/dist/index.js";
+import { IKnowledgeStore } from "../../store/dist/index.js";
+
+//#region packages/server/src/curated-manager.d.ts
+type CuratedCategory = string;
+interface CuratedEntry {
+  path: string;
+  title: string;
+  category: string;
+  tags: string[];
+  version: number;
+  created: string;
+  updated: string;
+  contentPreview: string;
+}
+interface CuratedFrontmatter {
+  title: string;
+  category: string;
+  tags: string[];
+  created: string;
+  updated: string;
+  version: number;
+  origin: 'curated';
+  changelog: Array<{
+    version: number;
+    date: string;
+    reason: string;
+  }>;
+}
+/**
+ * Manages curated knowledge files — the LLM's persistent memory.
+ * Files are stored as markdown in a .ai/curated/ directory with YAML frontmatter.
+ */
+declare class CuratedKnowledgeManager {
+  private readonly curatedDir;
+  private readonly store;
+  private readonly embedder;
+  constructor(curatedDir: string, store: IKnowledgeStore, embedder: IEmbedder);
+  remember(title: string, content: string, category: CuratedCategory, tags?: string[]): Promise<{
+    path: string;
+  }>;
+  update(relativePath: string, newContent: string, reason: string): Promise<{
+    path: string;
+    version: number;
+  }>;
+  forget(relativePath: string, _reason: string): Promise<{
+    path: string;
+  }>;
+  read(relativePath: string): Promise<CuratedEntry & {
+    content: string;
+  }>;
+  list(filters?: {
+    category?: CuratedCategory;
+    tag?: string;
+  }): Promise<CuratedEntry[]>;
+  /**
+   * Re-index all curated files into the vector store.
+   * Call this after the indexer has run to restore curated vectors
+   * that may have been lost, or to bulk-sync disk state to vectors.
+   */
+  reindexAll(): Promise<{
+    indexed: number;
+    errors: string[];
+  }>;
+  private indexCuratedFile;
+  private discoverCategories;
+  /**
+   * Normalize and validate a relative path within .ai/curated/.
+   * Returns the cleaned path (mutates nothing — caller must use the return value).
+   */
+  private guardPath;
+  private validateCategoryName;
+  private validateContentSize;
+  private slugify;
+  /** Return a unique `category/slug.md` path, appending `-2`, `-3`, … on collision. */
+  private uniqueRelativePath;
+  private hash;
+  private hashId;
+  /**
+   * Simple YAML frontmatter serializer (no gray-matter dependency).
+   */
+  private serializeFile;
+  /**
+   * Simple YAML frontmatter parser (no gray-matter dependency).
+   */
+  parseFile(raw: string): {
+    frontmatter: CuratedFrontmatter;
+    content: string;
+  };
+}
+//#endregion
+export { CuratedCategory, CuratedEntry, CuratedKnowledgeManager };

package/packages/server/dist/curated-manager.js

@@ -0,0 +1,5 @@
+import{dirname as e,isAbsolute as t,join as n}from"node:path";import{createLogger as r,serializeError as i}from"../../core/dist/index.js";import{createHash as a}from"node:crypto";import{mkdir as o,readFile as s,readdir as c,stat as l,unlink as u,writeFile as d}from"node:fs/promises";const f=50*1024,p=r(`server`);var m=class{constructor(e,t,n){this.curatedDir=e,this.store=t,this.embedder=n}async remember(t,r,i,a=[]){this.validateCategoryName(i),this.validateContentSize(r);let s=this.slugify(t),c=await this.uniqueRelativePath(i,s),l=n(this.curatedDir,c),f=new Date().toISOString(),p={title:t,category:i,tags:a,created:f,updated:f,version:1,origin:`curated`,changelog:[{version:1,date:f,reason:`Initial creation`}]},m=this.serializeFile(r,p);await o(e(l),{recursive:!0});try{await d(l,m,{encoding:`utf-8`,flag:`wx`})}catch(e){throw e.code===`EEXIST`?Error(`Concurrent write collision for "${c}" — retry the operation`):e}try{await this.indexCuratedFile(c,r,p)}catch(e){throw await u(l).catch(()=>{}),Error(`Remember failed: wrote file but indexing failed — rolled back. ${e.message}`)}return{path:c}}async update(e,t,r){e=this.guardPath(e),this.validateContentSize(t);let i=n(this.curatedDir,e),a=await s(i,`utf-8`),{frontmatter:o}=this.parseFile(a),c=(o.version??1)+1,l=new Date().toISOString();return o.version=c,o.updated=l,o.changelog=[...o.changelog??[],{version:c,date:l,reason:r}],await d(i,this.serializeFile(t,o),`utf-8`),await this.indexCuratedFile(e,t,o),{path:e,version:c}}async forget(e,t){e=this.guardPath(e),await u(n(this.curatedDir,e));let r=`.ai/curated/${e}`;return await this.store.deleteBySourcePath(r).catch(e=>{p.warn(`File deleted but vector cleanup failed`,{sourcePath:r,...i(e)})}),{path:e}}async read(e){e=this.guardPath(e);let t=await s(n(this.curatedDir,e),`utf-8`),{frontmatter:r,content:i}=this.parseFile(t),a=e.split(`/`)[0];return{path:e,title:r.title??e,category:a,tags:r.tags??[],version:r.version??1,created:r.created??``,updated:r.updated??``,contentPreview:i.slice(0,200),content:i}}async list(e){let t=[],r=e?.category?[e.category]:await this.discoverCategories();for(let i of r){let r=n(this.curatedDir,i);try{let a=await c(r);for(let o of a){if(!o.endsWith(`.md`))continue;let a=await s(n(r,o),`utf-8`),{frontmatter:c,content:l}=this.parseFile(a);e?.tag&&!(c.tags??[]).includes(e.tag)||t.push({path:`${i}/${o}`,title:c.title??o,category:i,tags:c.tags??[],version:c.version??1,created:c.created??``,updated:c.updated??``,contentPreview:l.slice(0,200)})}}catch{}}return t}async reindexAll(){let e=await this.discoverCategories(),t=[],r=[];for(let a of e){let e=n(this.curatedDir,a),o;try{o=(await c(e)).filter(e=>e.endsWith(`.md`))}catch{continue}for(let c of o){let o=`${a}/${c}`,l=n(e,c);try{let e=await s(l,`utf-8`),{frontmatter:t,content:n}=this.parseFile(e);r.push({relativePath:o,content:n,frontmatter:t})}catch(e){p.error(`Failed to read curated file`,{relativePath:o,...i(e)}),t.push(`${o}: read failed`)}}}if(r.length===0)return{indexed:0,errors:t};let a=await this.embedder.embedBatch(r.map(e=>e.content)),o=new Date().toISOString(),l=r.map(e=>{let t=`.ai/curated/${e.relativePath}`;return{id:this.hashId(t,0),content:e.content,sourcePath:t,contentType:`curated-knowledge`,headingPath:e.frontmatter.title,chunkIndex:0,totalChunks:1,startLine:1,endLine:e.content.split(`
+`).length,fileHash:this.hash(e.content),indexedAt:o,origin:`curated`,tags:e.frontmatter.tags,category:e.frontmatter.category,version:e.frontmatter.version}});return await this.store.upsert(l,a),{indexed:r.length,errors:t}}async indexCuratedFile(e,t,n){let r=await this.embedder.embed(t),i=`.ai/curated/${e}`,a=new Date().toISOString(),o={id:this.hashId(i,0),content:t,sourcePath:i,contentType:`curated-knowledge`,headingPath:n.title,chunkIndex:0,totalChunks:1,startLine:1,endLine:t.split(`
+`).length,fileHash:this.hash(t),indexedAt:a,origin:`curated`,tags:n.tags,category:n.category,version:n.version};await this.store.upsert([o],[r])}async discoverCategories(){try{return(await c(this.curatedDir,{withFileTypes:!0})).filter(e=>e.isDirectory()&&/^[a-z][a-z0-9-]*$/.test(e.name)).map(e=>e.name)}catch{return[]}}guardPath(e){let n=e.replace(/^\.ai\/curated\//,``);if(n.endsWith(`.md`)||(n+=`.md`),n.includes(`..`)||t(n))throw Error(`Invalid path: ${n}. Must be relative within .ai/curated/ directory.`);let r=n.split(`/`)[0];return this.validateCategoryName(r),n}validateCategoryName(e){if(!/^[a-z][a-z0-9-]*$/.test(e))throw Error(`Invalid category name: "${e}". Must be lowercase kebab-case (e.g., "decisions", "api-contracts").`)}validateContentSize(e){if(Buffer.byteLength(e,`utf-8`)>f)throw Error(`Content exceeds maximum size of ${f/1024}KB`)}slugify(e){return e.toLowerCase().replace(/[^a-z0-9]+/g,`-`).replace(/^-|-$/g,``).slice(0,80)}async uniqueRelativePath(e,t){let r=`${e}/${t}.md`,i=n(this.curatedDir,r);try{await l(i)}catch{return r}for(let r=2;r<=100;r++){let i=`${e}/${t}-${r}.md`;try{await l(n(this.curatedDir,i))}catch{return i}}throw Error(`Too many entries with slug "${t}" in category "${e}"`)}hash(e){return a(`sha256`).update(e).digest(`hex`).slice(0,16)}hashId(e,t){return this.hash(`${e}::${t}`)}serializeFile(e,t){return`${[`---`,`title: "${t.title.replace(/"/g,`\\"`)}"`,`category: ${t.category}`,`tags: [${t.tags.map(e=>`"${e}"`).join(`, `)}]`,`created: ${t.created}`,`updated: ${t.updated}`,`version: ${t.version}`,`origin: ${t.origin}`,`changelog:`,...t.changelog.map(e=>`  - version: ${e.version}\n    date: ${e.date}\n    reason: "${e.reason.replace(/"/g,`\\"`)}"`),`---`].join(`
+`)}\n\n${e}\n`}parseFile(e){let t=e.match(/^---\n([\s\S]*?)\n---\n\n?([\s\S]*)$/);if(!t)return{frontmatter:{title:`Untitled`,category:`notes`,tags:[],created:``,updated:``,version:1,origin:`curated`,changelog:[]},content:e};let n=t[1],r=t[2].trim(),i={},a=[],o=n.split(`
+`),s=!1,c={};for(let e of o){if(/^changelog:\s*$/.test(e)){s=!0;continue}if(s){let t=e.match(/^\s+-\s+version:\s*(\d+)$/);if(t){c.version!=null&&a.push(c),c={version:parseInt(t[1],10)};continue}let n=e.match(/^\s+date:\s*(.+)$/);if(n){c.date=n[1].trim();continue}let r=e.match(/^\s+reason:\s*"?(.*?)"?\s*$/);if(r){c.reason=r[1];continue}/^\w/.test(e)&&(s=!1,c.version!=null&&a.push(c),c={});continue}let t=e.match(/^(\w+):\s*(.*)$/);if(t){let e=t[1],n=t[2];typeof n==`string`&&n.startsWith(`[`)&&n.endsWith(`]`)?n=n.slice(1,-1).split(`,`).map(e=>e.trim().replace(/^"|"$/g,``)).filter(e=>e.length>0):typeof n==`string`&&/^\d+$/.test(n)?n=parseInt(n,10):typeof n==`string`&&n.startsWith(`"`)&&n.endsWith(`"`)&&(n=n.slice(1,-1)),i[e]=n}}return c.version!=null&&a.push(c),{frontmatter:{title:i.title??`Untitled`,category:i.category??`notes`,tags:i.tags??[],created:i.created??``,updated:i.updated??``,version:i.version??1,origin:`curated`,changelog:a},content:r}}};export{m as CuratedKnowledgeManager};

package/packages/server/dist/dashboard-static.d.ts

@@ -0,0 +1,27 @@
+import * as _$express from "express";
+
+//#region packages/server/src/dashboard-static.d.ts
+type DashboardApp = {
+  get: (path: string, handler: (req: _$express.Request, res: _$express.Response) => void) => void;
+};
+type DashboardLogger = {
+  info: (message: string, meta?: Record<string, unknown>) => void;
+};
+type DashboardRequestResolution = {
+  kind: 'file';
+  path: string;
+  contentType: string;
+} | {
+  kind: 'spa';
+  path: string;
+  contentType: 'text/html';
+} | {
+  kind: 'forbidden';
+} | {
+  kind: 'not-found';
+};
+declare function resolveDashboardDir(baseDir?: string): string;
+declare function resolveDashboardRequest(dashboardDir: string, requestPath: string): DashboardRequestResolution;
+declare function registerDashboardRoutes(app: DashboardApp, dashboardDir: string, logger: DashboardLogger): boolean;
+//#endregion
+export { DashboardRequestResolution, registerDashboardRoutes, resolveDashboardDir, resolveDashboardRequest };

package/packages/server/dist/dashboard-static.js

@@ -0,0 +1 @@
+import{createReadStream as e,existsSync as t,statSync as n}from"node:fs";import{dirname as r,extname as i,join as a,resolve as o,sep as s}from"node:path";import{fileURLToPath as c}from"node:url";const l=import.meta.dirname??r(c(import.meta.url)),u={".html":`text/html`,".js":`application/javascript`,".css":`text/css`,".json":`application/json`,".png":`image/png`,".svg":`image/svg+xml`,".ico":`image/x-icon`,".woff":`font/woff`,".woff2":`font/woff2`};function d(e=l){return a(e,`..`,`..`,`dashboard`,`dist`)}function f(e,r){let c=r.replace(/^\/_dashboard\/?/,``)||`index.html`;try{c=decodeURIComponent(c)}catch{}let l=o(e,c);if(!(l===e||l.startsWith(`${e}${s}`)))return{kind:`forbidden`};try{if(n(l).isFile())return{kind:`file`,path:l,contentType:u[i(l)]??`application/octet-stream`}}catch{}let d=a(e,`index.html`);return t(d)?{kind:`spa`,path:d,contentType:`text/html`}:{kind:`not-found`}}function p(n,r,i){return t(r)?(n.get(`/_dashboard{/*path}`,(t,n)=>{let i=f(r,t.path);if(i.kind===`forbidden`){n.status(403).end(`Forbidden`);return}if(i.kind===`not-found`){n.status(404).end(`Not found`);return}n.setHeader(`Content-Type`,i.contentType),i.kind===`file`&&/\.[a-f0-9]{8,}\.(js|css)$/i.test(i.path)?n.setHeader(`Cache-Control`,`public, max-age=31536000, immutable`):n.setHeader(`Cache-Control`,`no-cache`),e(i.path).pipe(n)}),i.info(`Dashboard available`,{url:`/_dashboard/`,dir:r}),!0):!1}export{p as registerDashboardRoutes,d as resolveDashboardDir,f as resolveDashboardRequest};

package/packages/server/dist/elicitor.d.ts

@@ -0,0 +1,18 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { Elicitor } from "../../elicitation/dist/index.js";
+
+//#region packages/server/src/elicitor.d.ts
+/**
+ * Create an Elicitor backed by the MCP server's elicitInput capability.
+ *
+ * All methods degrade gracefully: if the client does not support elicitation,
+ * they return decline / false / null / [] defaults without throwing.
+ */
+declare function createElicitor(mcpServer: McpServer): Elicitor;
+/**
+ * No-op Elicitor — always returns decline / false / null / [].
+ * Used when no MCP server is available.
+ */
+declare const noopElicitor: Elicitor;
+//#endregion
+export { createElicitor, noopElicitor };

package/packages/server/dist/elicitor.js

@@ -0,0 +1 @@
+import{buildFormSchema as e,field as t,normalizeResponse as n}from"../../elicitation/dist/index.js";function r(r){function i(){return!!r.server?.getClientCapabilities?.()?.elicitation}async function a(e,t){if(i())try{let i=await r.server.elicitInput({message:e,requestedSchema:t});return n(i?{action:i.action,content:i.content}:void 0)}catch{return}}return{get available(){return i()},async ask(e){return await a(e.message,e.schema)||{action:`decline`}},async confirm(n){let r=await a(n,e({confirmed:t.confirm(n)}));return r?.action===`accept`&&r.content?.confirmed===!0},async selectOne(n,r){let i=await a(n,e({selection:t.select(`Choose one`,r)}));if(i?.action!==`accept`)return null;let o=i.content?.selection;return typeof o==`string`?o:null},async selectMany(n,r){let i=await a(n,e({selections:t.multi(`Choose one or more`,r)}));if(i?.action!==`accept`)return[];let o=i.content?.selections;return Array.isArray(o)?o:[]},async promptText(n,r){let i=await a(n,e({text:t.text(n,{description:r})}));if(i?.action!==`accept`)return null;let o=i.content?.text;return typeof o==`string`?o:null}}}const i={available:!1,async ask(){return{action:`decline`}},async confirm(){return!1},async selectOne(){return null},async selectMany(){return[]},async promptText(){return null}};export{r as createElicitor,i as noopElicitor};

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

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

package/packages/server/dist/index.js

@@ -0,0 +1 @@
+import{readFileSync as e}from"node:fs";import{dirname as t,resolve as n}from"node:path";import{fileURLToPath as r}from"node:url";import{createLogger as i,serializeError as a}from"../../core/dist/index.js";import{parseArgs as o}from"node:util";const s=t(r(import.meta.url)),c=(()=>{try{let t=n(s,`..`,`..`,`..`,`package.json`);return JSON.parse(e(t,`utf-8`)).version??`0.0.0`}catch{return`0.0.0`}})(),l=i(`server`),{values:u}=o({options:{transport:{type:`string`,default:process.env.AIKIT_TRANSPORT??`stdio`},port:{type:`string`,default:process.env.AIKIT_PORT??`3210`}}});async function d(){if(process.on(`unhandledRejection`,e=>{l.error(`Unhandled rejection`,a(e))}),l.info(`Starting MCP Knowledge Base server`,{version:c}),u.transport===`http`){let[{default:e},{loadConfig:t},{registerDashboardRoutes:n,resolveDashboardDir:r}]=await Promise.all([import(`express`),import(`./config.js`),import(`./dashboard-static.js`)]),i=t();l.info(`Config loaded`,{sourceCount:i.sources.length,storePath:i.store.path});let o=e();o.use(e.json());let s=Number(u.port);o.use((e,t,n)=>{if(t.setHeader(`Access-Control-Allow-Origin`,process.env.AIKIT_CORS_ORIGIN??`http://localhost:${s}`),t.setHeader(`Access-Control-Allow-Methods`,`GET, POST, DELETE, OPTIONS`),t.setHeader(`Access-Control-Allow-Headers`,`Content-Type, Authorization`),e.method===`OPTIONS`){t.status(204).end();return}n()}),n(o,r(),l),o.get(`/health`,(e,t)=>{t.json({status:`ok`})});let c=!1,d=null,f=null,p=Promise.resolve();o.post(`/mcp`,async(e,t)=>{if(!c||!d||!f){t.status(503).json({jsonrpc:`2.0`,error:{code:-32603,message:`Server initializing — please retry in a few seconds`},id:null});return}let n=p,r;p=new Promise(e=>{r=e}),await n;try{let n=new f({sessionIdGenerator:void 0});await d.connect(n),await n.handleRequest(e,t,e.body),n.close()}catch(e){if(l.error(`MCP handler error`,a(e)),!t.headersSent){let n=e instanceof Error?e.message:String(e),r=n.includes(`Not Acceptable`);t.status(r?406:500).json({jsonrpc:`2.0`,error:{code:r?-32e3:-32603,message:r?n:`Internal server error`},id:null})}}finally{r()}}),o.get(`/mcp`,(e,t)=>{t.writeHead(405).end(JSON.stringify({jsonrpc:`2.0`,error:{code:-32e3,message:`Method not allowed.`},id:null}))}),o.delete(`/mcp`,(e,t)=>{t.writeHead(405).end(JSON.stringify({jsonrpc:`2.0`,error:{code:-32e3,message:`Method not allowed.`},id:null}))});let m=o.listen(s,`127.0.0.1`,()=>{l.info(`MCP server listening`,{url:`http://127.0.0.1:${s}/mcp`,port:s}),setTimeout(async()=>{try{let[{createLazyServer:e,ALL_TOOL_NAMES:t},{StreamableHTTPServerTransport:n},{checkForUpdates:r,autoUpgradeScaffold:o}]=await Promise.all([import(`./server.js`),import(`@modelcontextprotocol/sdk/server/streamableHttp.js`),import(`./version-check.js`)]);r(),o();let s=e(i);d=s.server,f=n,c=!0,l.info(`MCP server configured (lazy — KB initializing in background)`,{toolCount:t.length,resourceCount:2}),s.startInit(),process.env.AIKIT_AUTO_INDEX===`true`?s.ready.then(async()=>{try{let e=i.sources.map(e=>e.path).join(`, `);l.info(`Running initial index`,{sourcePaths:e}),await s.runInitialIndex(),l.info(`Initial index complete`)}catch(e){l.error(`Initial index failed; will retry on aikit_reindex`,a(e))}}).catch(e=>l.error(`KB init or indexing failed`,a(e))):(s.ready.catch(e=>l.error(`KB initialization failed`,a(e))),l.info(`Auto-index disabled in HTTP mode (set AIKIT_AUTO_INDEX=true to enable)`))}catch(e){l.error(`Failed to load server modules`,a(e))}},100)}),h=async e=>{l.info(`Shutdown signal received`,{signal:e}),m.close(),d&&await d.close(),process.exit(0)};process.on(`SIGINT`,()=>h(`SIGINT`)),process.on(`SIGTERM`,()=>h(`SIGTERM`))}else{let[{loadConfig:e,reconfigureForWorkspace:t},{createLazyServer:n},{checkForUpdates:i,autoUpgradeScaffold:o},{RootsListChangedNotificationSchema:s}]=await Promise.all([import(`./config.js`),import(`./server.js`),import(`./version-check.js`),import(`@modelcontextprotocol/sdk/types.js`)]),c=e();l.info(`Config loaded`,{sourceCount:c.sources.length,storePath:c.store.path}),i(),o();let{server:u,startInit:d,ready:f,runInitialIndex:p}=n(c),{StdioServerTransport:m}=await import(`@modelcontextprotocol/sdk/server/stdio.js`),h=new m;await u.connect(h),l.info(`MCP server started`,{transport:`stdio`});let g=e=>{if(e.length===0)return!1;let n=e[0].uri,i=n.startsWith(`file://`)?r(n):n;return l.info(`MCP roots resolved`,{rootUri:n,rootPath:i,rootCount:e.length}),t(c,i),!0},_=!1;try{_=g((await u.server.listRoots()).roots),_||l.info(`No MCP roots yet; waiting for roots/list_changed notification`)}catch(e){l.warn(`MCP roots/list not supported by client; using cwd fallback`,{cwd:process.cwd(),...a(e)}),_=!0}_||=await new Promise(e=>{let t=setTimeout(()=>{l.warn(`Timed out waiting for MCP roots/list_changed; using cwd fallback`,{cwd:process.cwd()}),e(!1)},5e3);u.server.setNotificationHandler(s,async()=>{clearTimeout(t);try{e(g((await u.server.listRoots()).roots))}catch(t){l.warn(`roots/list retry failed after notification`,a(t)),e(!1)}})}),d(),f.catch(e=>{l.error(`Initialization failed — server will continue with limited tools`,a(e))}),process.env.AIKIT_AUTO_INDEX===`false`?l.warn(`Auto-index disabled; use aikit_reindex to index manually`):p().catch(e=>l.error(`Initial index failed`,a(e)))}}d().catch(e=>{l.error(`Fatal error`,a(e)),process.exit(1)});export{};

package/packages/server/dist/mcp-logging.d.ts

@@ -0,0 +1,11 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+//#region packages/server/src/mcp-logging.d.ts
+/**
+ * Bridge internal logger messages to MCP client via `sendLoggingMessage`.
+ * Fire-and-forget — never blocks the log caller, never throws.
+ * Returns a cleanup function to remove the bridge.
+ */
+declare function bridgeMcpLogging(server: McpServer): () => void;
+//#endregion
+export { bridgeMcpLogging };

package/packages/server/dist/mcp-logging.js

@@ -0,0 +1 @@
+import{addLogListener as e}from"../../core/dist/index.js";const t={debug:`debug`,info:`info`,warn:`warning`,error:`error`};function n(n){return e(({level:e,component:r,message:i,data:a})=>{try{Promise.resolve(n.sendLoggingMessage({level:t[e],logger:r,data:a?{message:i,...a}:i})).catch(()=>{})}catch{}})}export{n as bridgeMcpLogging};

package/packages/server/dist/output-schemas.d.ts

@@ -0,0 +1,242 @@
+import { z } from "zod";
+
+//#region packages/server/src/output-schemas.d.ts
+/**
+ * Centralized output schemas for MCP tools that return naturally structured data.
+ *
+ * Phase 1: status, list, health, measure, env, time
+ * These schemas are used with `outputSchema` in tool registration and validated
+ * by the SDK at runtime. Keep them intentionally flat and stable — do not leak
+ * internal storage record shapes.
+ */
+declare const StatusOutputSchema: z.ZodObject<{
+  totalRecords: z.ZodNumber;
+  totalFiles: z.ZodNumber;
+  lastIndexedAt: z.ZodNullable<z.ZodString>;
+  onboarded: z.ZodBoolean;
+  onboardDir: z.ZodString;
+  contentTypes: z.ZodRecord<z.ZodString, z.ZodNumber>;
+  wasmAvailable: z.ZodBoolean;
+  graphStats: z.ZodNullable<z.ZodObject<{
+    nodes: z.ZodNumber;
+    edges: z.ZodNumber;
+  }, z.core.$strip>>;
+  curatedCount: z.ZodNumber;
+  serverVersion: z.ZodString;
+  scaffoldVersion: z.ZodNullable<z.ZodString>;
+  workspaceScaffoldVersion: z.ZodNullable<z.ZodString>;
+  upgradeAvailable: z.ZodBoolean;
+}, z.core.$strip>;
+declare const ListOutputSchema: z.ZodObject<{
+  entries: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    title: z.ZodString;
+    category: z.ZodString;
+    tags: z.ZodArray<z.ZodString>;
+    version: z.ZodNumber;
+    preview: z.ZodString;
+  }, z.core.$strip>>;
+  totalCount: z.ZodNumber;
+}, z.core.$strip>;
+declare const HealthOutputSchema: z.ZodObject<{
+  ok: z.ZodBoolean;
+  checks: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    ok: z.ZodBoolean;
+    message: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const MeasureOutputSchema: z.ZodObject<{
+  summary: z.ZodObject<{
+    totalFiles: z.ZodNumber;
+    totalLines: z.ZodNumber;
+    totalCodeLines: z.ZodNumber;
+    totalFunctions: z.ZodNumber;
+    avgComplexity: z.ZodNumber;
+    maxComplexity: z.ZodObject<{
+      value: z.ZodNumber;
+      file: z.ZodString;
+    }, z.core.$strip>;
+  }, z.core.$strip>;
+  files: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    lines: z.ZodNumber;
+    code: z.ZodNumber;
+    complexity: z.ZodNumber;
+    functions: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const EnvOutputSchema: z.ZodObject<{
+  platform: z.ZodString;
+  arch: z.ZodString;
+  nodeVersion: z.ZodString;
+  cwd: z.ZodString;
+  cpus: z.ZodNumber;
+  memoryFreeGb: z.ZodNumber;
+  memoryTotalGb: z.ZodNumber;
+}, z.core.$strip>;
+declare const TimeOutputSchema: z.ZodObject<{
+  iso: z.ZodString;
+  unix: z.ZodNumber;
+  timezone: z.ZodString;
+  formatted: z.ZodString;
+}, z.core.$strip>;
+declare const CheckOutputSchema: z.ZodObject<{
+  passed: z.ZodBoolean;
+  tsc: z.ZodObject<{
+    passed: z.ZodBoolean;
+    errorCount: z.ZodNumber;
+    warningCount: z.ZodNumber;
+    topErrors: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>;
+  biome: z.ZodObject<{
+    passed: z.ZodBoolean;
+    errorCount: z.ZodNumber;
+    warningCount: z.ZodNumber;
+    topErrors: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+declare const SymbolOutputSchema: z.ZodObject<{
+  name: z.ZodString;
+  definedIn: z.ZodNullable<z.ZodObject<{
+    path: z.ZodString;
+    line: z.ZodNumber;
+    kind: z.ZodString;
+    signature: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  importedBy: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    line: z.ZodNumber;
+    importStatement: z.ZodString;
+  }, z.core.$strip>>;
+  referencedIn: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    line: z.ZodNumber;
+    context: z.ZodString;
+    scope: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  graphContext: z.ZodNullable<z.ZodObject<{
+    definingModule: z.ZodOptional<z.ZodString>;
+    importedByModules: z.ZodArray<z.ZodString>;
+    siblingSymbols: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const SearchOutputSchema: z.ZodObject<{
+  results: z.ZodArray<z.ZodObject<{
+    sourcePath: z.ZodString;
+    contentType: z.ZodString;
+    score: z.ZodNumber;
+    headingPath: z.ZodOptional<z.ZodString>;
+    startLine: z.ZodOptional<z.ZodNumber>;
+    endLine: z.ZodOptional<z.ZodNumber>;
+    origin: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }, z.core.$strip>>;
+  totalResults: z.ZodNumber;
+  searchMode: z.ZodString;
+  query: z.ZodString;
+}, z.core.$strip>;
+declare const FindOutputSchema: z.ZodObject<{
+  matches: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    line: z.ZodOptional<z.ZodNumber>;
+    matchType: z.ZodString;
+    preview: z.ZodString;
+  }, z.core.$strip>>;
+  totalMatches: z.ZodNumber;
+  pattern: z.ZodString;
+  truncated: z.ZodBoolean;
+}, z.core.$strip>;
+declare const ScopeMapOutputSchema: z.ZodObject<{
+  files: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    relevance: z.ZodNumber;
+    estimatedTokens: z.ZodNumber;
+    focusLines: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }, z.core.$strip>>;
+  totalFiles: z.ZodNumber;
+  totalEstimatedTokens: z.ZodNumber;
+  task: z.ZodString;
+}, z.core.$strip>;
+declare const BlastRadiusOutputSchema: z.ZodObject<{
+  changedFiles: z.ZodArray<z.ZodString>;
+  affectedFiles: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    impact: z.ZodString;
+    reason: z.ZodString;
+  }, z.core.$strip>>;
+  totalAffected: z.ZodNumber;
+  riskLevel: z.ZodString;
+}, z.core.$strip>;
+declare const AuditOutputSchema: z.ZodObject<{
+  passed: z.ZodBoolean;
+  score: z.ZodNumber;
+  checks: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    passed: z.ZodBoolean;
+    message: z.ZodOptional<z.ZodString>;
+    severity: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  summary: z.ZodString;
+}, z.core.$strip>;
+declare const GraphOutputSchema: z.ZodObject<{
+  nodes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodString;
+    sourcePath: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  edges: z.ZodArray<z.ZodObject<{
+    fromId: z.ZodString;
+    toId: z.ZodString;
+    type: z.ZodString;
+  }, z.core.$strip>>;
+  totalNodes: z.ZodNumber;
+  totalEdges: z.ZodNumber;
+  query: z.ZodString;
+}, z.core.$strip>;
+declare const DeadSymbolsOutputSchema: z.ZodObject<{
+  symbols: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+    line: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodString;
+  }, z.core.$strip>>;
+  totalDead: z.ZodNumber;
+}, z.core.$strip>;
+declare const AnalyzeStructureOutputSchema: z.ZodObject<{
+  files: z.ZodNumber;
+  packages: z.ZodNumber;
+  languages: z.ZodRecord<z.ZodString, z.ZodNumber>;
+  tree: z.ZodString;
+}, z.core.$strip>;
+declare const FileSummaryOutputSchema: z.ZodObject<{
+  path: z.ZodString;
+  language: z.ZodString;
+  lines: z.ZodNumber;
+  imports: z.ZodNumber;
+  exports: z.ZodNumber;
+  functions: z.ZodNumber;
+  classes: z.ZodNumber;
+}, z.core.$strip>;
+declare const GitContextOutputSchema: z.ZodObject<{
+  gitRoot: z.ZodString;
+  branch: z.ZodString;
+  commitCount: z.ZodNumber;
+  hasUncommitted: z.ZodBoolean;
+  recentCommits: z.ZodArray<z.ZodObject<{
+    hash: z.ZodString;
+    message: z.ZodString;
+    author: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const CompactOutputSchema: z.ZodObject<{
+  originalChars: z.ZodNumber;
+  compressedChars: z.ZodNumber;
+  ratio: z.ZodNumber;
+  segmentsKept: z.ZodNumber;
+  segmentsTotal: z.ZodNumber;
+}, z.core.$strip>;
+//#endregion
+export { AnalyzeStructureOutputSchema, AuditOutputSchema, BlastRadiusOutputSchema, CheckOutputSchema, CompactOutputSchema, DeadSymbolsOutputSchema, EnvOutputSchema, FileSummaryOutputSchema, FindOutputSchema, GitContextOutputSchema, GraphOutputSchema, HealthOutputSchema, ListOutputSchema, MeasureOutputSchema, ScopeMapOutputSchema, SearchOutputSchema, StatusOutputSchema, SymbolOutputSchema, TimeOutputSchema };

package/packages/server/dist/output-schemas.js

@@ -0,0 +1 @@
+import{z as e}from"zod";const t=e.object({totalRecords:e.number(),totalFiles:e.number(),lastIndexedAt:e.string().nullable(),onboarded:e.boolean(),onboardDir:e.string(),contentTypes:e.record(e.string(),e.number()),wasmAvailable:e.boolean(),graphStats:e.object({nodes:e.number(),edges:e.number()}).nullable(),curatedCount:e.number(),serverVersion:e.string(),scaffoldVersion:e.string().nullable(),workspaceScaffoldVersion:e.string().nullable(),upgradeAvailable:e.boolean()}),n=e.object({entries:e.array(e.object({path:e.string(),title:e.string(),category:e.string(),tags:e.array(e.string()),version:e.number(),preview:e.string()})),totalCount:e.number()}),r=e.object({ok:e.boolean(),checks:e.array(e.object({name:e.string(),ok:e.boolean(),message:e.string().optional()}))}),i=e.object({summary:e.object({totalFiles:e.number(),totalLines:e.number(),totalCodeLines:e.number(),totalFunctions:e.number(),avgComplexity:e.number(),maxComplexity:e.object({value:e.number(),file:e.string()})}),files:e.array(e.object({path:e.string(),lines:e.number(),code:e.number(),complexity:e.number(),functions:e.number()}))}),a=e.object({platform:e.string(),arch:e.string(),nodeVersion:e.string(),cwd:e.string(),cpus:e.number(),memoryFreeGb:e.number(),memoryTotalGb:e.number()}),o=e.object({iso:e.string(),unix:e.number(),timezone:e.string(),formatted:e.string()}),s=e.object({passed:e.boolean(),errorCount:e.number(),warningCount:e.number(),topErrors:e.array(e.string())}),c=e.object({passed:e.boolean(),tsc:s,biome:s}),l=e.object({name:e.string(),definedIn:e.object({path:e.string(),line:e.number(),kind:e.string(),signature:e.string().optional()}).nullable(),importedBy:e.array(e.object({path:e.string(),line:e.number(),importStatement:e.string()})),referencedIn:e.array(e.object({path:e.string(),line:e.number(),context:e.string(),scope:e.string().optional()})),graphContext:e.object({definingModule:e.string().optional(),importedByModules:e.array(e.string()),siblingSymbols:e.array(e.string())}).nullable()}),u=e.object({sourcePath:e.string(),contentType:e.string(),score:e.number(),headingPath:e.string().optional(),startLine:e.number().optional(),endLine:e.number().optional(),origin:e.string().optional(),category:e.string().optional(),tags:e.array(e.string()).optional()}),d=e.object({results:e.array(u),totalResults:e.number(),searchMode:e.string(),query:e.string()}),f=e.object({path:e.string(),line:e.number().optional(),matchType:e.string(),preview:e.string()}),p=e.object({matches:e.array(f),totalMatches:e.number(),pattern:e.string(),truncated:e.boolean()}),m=e.object({path:e.string(),relevance:e.number(),estimatedTokens:e.number(),focusLines:e.array(e.string()).optional()}),h=e.object({files:e.array(m),totalFiles:e.number(),totalEstimatedTokens:e.number(),task:e.string()}),g=e.object({path:e.string(),impact:e.string(),reason:e.string()}),_=e.object({changedFiles:e.array(e.string()),affectedFiles:e.array(g),totalAffected:e.number(),riskLevel:e.string()}),v=e.object({name:e.string(),passed:e.boolean(),message:e.string().optional(),severity:e.string().optional()}),y=e.object({passed:e.boolean(),score:e.number(),checks:e.array(v),summary:e.string()}),b=e.object({id:e.string(),name:e.string(),type:e.string(),sourcePath:e.string().optional()}),x=e.object({fromId:e.string(),toId:e.string(),type:e.string()}),S=e.object({nodes:e.array(b),edges:e.array(x),totalNodes:e.number(),totalEdges:e.number(),query:e.string()}),C=e.object({symbols:e.array(e.object({name:e.string(),path:e.string(),line:e.number().optional(),kind:e.string()})),totalDead:e.number()}),w=e.object({files:e.number(),packages:e.number(),languages:e.record(e.string(),e.number()),tree:e.string()}),T=e.object({path:e.string(),language:e.string(),lines:e.number(),imports:e.number(),exports:e.number(),functions:e.number(),classes:e.number()}),E=e.object({gitRoot:e.string(),branch:e.string(),commitCount:e.number(),hasUncommitted:e.boolean(),recentCommits:e.array(e.object({hash:e.string(),message:e.string(),author:e.string()}))}),D=e.object({originalChars:e.number(),compressedChars:e.number(),ratio:e.number(),segmentsKept:e.number(),segmentsTotal:e.number()});export{w as AnalyzeStructureOutputSchema,y as AuditOutputSchema,_ as BlastRadiusOutputSchema,c as CheckOutputSchema,D as CompactOutputSchema,C as DeadSymbolsOutputSchema,a as EnvOutputSchema,T as FileSummaryOutputSchema,p as FindOutputSchema,E as GitContextOutputSchema,S as GraphOutputSchema,r as HealthOutputSchema,n as ListOutputSchema,i as MeasureOutputSchema,h as ScopeMapOutputSchema,d as SearchOutputSchema,t as StatusOutputSchema,l as SymbolOutputSchema,o as TimeOutputSchema};

package/packages/server/dist/prompts.d.ts

@@ -0,0 +1,13 @@
+import { CuratedKnowledgeManager } from "./curated-manager.js";
+import { IGraphStore, IKnowledgeStore } from "../../store/dist/index.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+//#region packages/server/src/prompts.d.ts
+interface PromptDependencies {
+  curated: CuratedKnowledgeManager;
+  store: IKnowledgeStore;
+  graphStore: IGraphStore;
+}
+declare function registerPrompts(server: McpServer, deps?: PromptDependencies): void;
+//#endregion
+export { PromptDependencies, registerPrompts };