@dikolab/kbdb 0.1.0

package/dist/src/shared/cli/functions/run-migrate.function.d.ts

@@ -0,0 +1,57 @@
+import type { CliOptions } from '../typings/cli-options.interface.ts';
+import type { MigrateResult } from '../../worker-client/typings/migrate-result.model.ts';
+import type { VersionCompatibility, VersionStatus } from '../../worker-client/typings/version-status.model.ts';
+/**
+ * Result returned by `runMigrate` describing the outcome of the
+ * migration attempt.
+ */
+export interface MigrateCommandResult {
+    /**
+     * The compatibility status returned by the version check.
+     * Mirrors `VersionStatus.status`.
+     */
+    readonly status: VersionCompatibility;
+    /** Full version status from the pre-migration check. */
+    readonly versionStatus: VersionStatus;
+    /**
+     * Migration report when `status` is `'needs_migration'`.
+     * `undefined` for `'compatible'` and `'too_new'` outcomes.
+     */
+    readonly migrateResult?: MigrateResult;
+}
+/**
+ * Minimal client interface required by `runMigrate`.
+ *
+ * Decouples the CLI function from the concrete `WorkerClient`
+ * implementation, making it straightforward to test with mocks.
+ */
+export interface MigrateClient {
+    /**
+     * Checks the database format version against the WASM engine.
+     *
+     * @param targetPath - absolute path to the `.kbdb` database root
+     */
+    checkVersion(targetPath: string): Promise<VersionStatus>;
+    /**
+     * Runs all pending database migrations.
+     *
+     * @param targetPath - absolute path to the `.kbdb` database root
+     */
+    migrateDatabase(targetPath: string): Promise<MigrateResult>;
+}
+/**
+ * Checks the database version and runs pending migrations when needed.
+ *
+ * Resolution order:
+ * - `'compatible'`: returns without running migrations
+ * - `'needs_migration'`: calls `client.migrateDatabase` and returns
+ *   the migration report
+ * - `'too_new'`: returns without running migrations (caller should
+ *   print an error and exit non-zero)
+ *
+ * @param client - migrate client to delegate to
+ * @param options - parsed CLI options supplying the optional `dbPath`
+ * @returns result containing the version status and optional migration
+ *   report
+ */
+export declare function runMigrate(client: MigrateClient, options: CliOptions): Promise<MigrateCommandResult>;

package/dist/src/shared/cli/functions/run-rebuild.function.d.ts

@@ -0,0 +1,40 @@
+import type { CliOptions } from '../typings/cli-options.interface.ts';
+/**
+ * Index rebuild report returned by the daemon.
+ */
+interface RebuildResult {
+    /** Number of text and code sections that were re-indexed. */
+    readonly sections_reindexed: number;
+    /** Total number of unique terms written to the rebuilt indexes. */
+    readonly terms_indexed: number;
+    /** Time taken to complete the rebuild, in milliseconds. */
+    readonly elapsed_ms: number;
+}
+/**
+ * Minimal client interface required by `runRebuild`.
+ *
+ * Decouples the CLI function from the concrete `WorkerClient`
+ * implementation, making it straightforward to test with mocks.
+ */
+export interface RebuildClient {
+    /**
+     * Reconstructs all index files from section files and document
+     * manifests on disk. Text and code sections are re-tokenized;
+     * image sections are skipped.
+     *
+     * @returns a report of sections and terms re-indexed
+     */
+    rebuildIndexes(): Promise<RebuildResult>;
+}
+/**
+ * Rebuilds all database indexes and returns the report.
+ *
+ * Delegates to `client.rebuildIndexes()`. The caller is responsible
+ * for printing the result to stdout.
+ *
+ * @param client - rebuild client to delegate to
+ * @param _options - parsed CLI options (unused; reserved for future flags)
+ * @returns the index rebuild report from the daemon
+ */
+export declare function runRebuild(client: RebuildClient, _options: CliOptions): Promise<RebuildResult>;
+export {};

package/dist/src/shared/cli/functions/run-search.function.d.ts

@@ -0,0 +1,39 @@
+import type { CliOptions } from '../typings/cli-options.interface.ts';
+import type { SearchDisplay } from '../typings/search-display.model.ts';
+/**
+ * Minimal client interface required by `runSearch`.
+ *
+ * Decouples the CLI function from the concrete `WorkerClient`
+ * implementation, making it straightforward to test with mocks.
+ */
+export interface SearchClient {
+    /**
+     * Searches the knowledge base and returns ranked results.
+     *
+     * @param params - query, mode, and result limit
+     */
+    search(params: {
+        query: string;
+        mode?: string;
+        limit?: number;
+    }): Promise<{
+        kbid: string;
+        score: number;
+        readonly matches: readonly {
+            readonly term: string;
+            readonly frequency: number;
+        }[];
+    }[]>;
+}
+/**
+ * Executes a search query via the provided client and maps the raw
+ * daemon results to the `SearchDisplay` format used by the CLI.
+ *
+ * Returns an empty array without calling the client when `options.args`
+ * contains no query terms.
+ *
+ * @param client - search client to delegate to
+ * @param options - parsed CLI options supplying query args and search
+ *   parameters
+ */
+export declare function runSearch(client: SearchClient, options: CliOptions): Promise<SearchDisplay[]>;

package/dist/src/shared/cli/functions/run-skill-delete.function.d.ts

@@ -0,0 +1,30 @@
+import type { CliOptions } from '../typings/cli-options.interface.ts';
+import type { CommandResult } from '../typings/command-result.model.ts';
+/**
+ * Minimal client interface required by `runSkillDelete`.
+ *
+ * Decouples the CLI function from the concrete `WorkerClient`
+ * implementation, making it straightforward to test with mocks.
+ */
+export interface SkillDeleteClient {
+    /**
+     * Removes a section from the knowledge base.
+     *
+     * @param kbid - knowledge-base identifier of the section to remove
+     * @returns result indicating whether the section was found and removed
+     */
+    removeSection(kbid: string): Promise<{
+        removed: boolean;
+    }>;
+}
+/**
+ * Deletes a skill section from the knowledge base by its kbid.
+ *
+ * The kbid must be supplied as the first positional argument. Returns
+ * an error result if it is missing.
+ *
+ * @param client - client used to remove the skill section
+ * @param options - parsed CLI options; `args[0]` is the kbid
+ * @returns a `CommandResult` with the kbid and removal status
+ */
+export declare function runSkillDelete(client: SkillDeleteClient, options: CliOptions): Promise<CommandResult>;

package/dist/src/shared/cli/functions/run-skill-get.function.d.ts

@@ -0,0 +1,49 @@
+import type { CliOptions } from '../typings/cli-options.interface.ts';
+import type { CommandResult } from '../typings/command-result.model.ts';
+/**
+ * Minimal client interface required by `runSkillGet`.
+ *
+ * Decouples the CLI function from the concrete `WorkerClient`
+ * implementation, making it straightforward to test with mocks.
+ */
+export interface SkillGetClient {
+    /**
+     * Retrieves one or more sections by their knowledge-base IDs.
+     *
+     * @param kbids - list of knowledge-base identifiers to fetch
+     * @returns matching section rows
+     */
+    readSections(kbids: string[]): Promise<{
+        kbid: string;
+        content: string;
+    }[]>;
+    /**
+     * Retrieves all sections stored with the given type name.
+     *
+     * @param sectionType - the type name to filter by
+     * @returns matching section rows
+     */
+    listByType(sectionType: string): Promise<{
+        kbid: string;
+        title: string | null;
+        content: string;
+    }[]>;
+}
+/**
+ * Retrieves a skill definition by name or kbid.
+ *
+ * Accepts the identifier as the first positional argument or as
+ * `options.name`. When the identifier looks like a hex hash
+ * (16 or more hex characters) it is tried as a kbid first; if
+ * no section is found it falls back to a name lookup. When the
+ * identifier is not hex-like it goes directly to name lookup.
+ * For name lookups the most recently stored match (last in the
+ * array) is returned.
+ *
+ * @param client - client used to look up the skill section
+ * @param options - parsed CLI options; first positional arg or `name`
+ *   is used as the identifier
+ * @returns a `CommandResult` containing the serialized
+ *   `SkillDefinition` JSON or an error message
+ */
+export declare function runSkillGet(client: SkillGetClient, options: CliOptions): Promise<CommandResult>;

package/dist/src/shared/cli/functions/run-skill-learn.function.d.ts

@@ -0,0 +1,36 @@
+import type { CliOptions } from '../typings/cli-options.interface.ts';
+import type { CommandResult } from '../typings/command-result.model.ts';
+import type { AddSectionResult } from '../../worker-client/typings/add-section-result.model.ts';
+/**
+ * Minimal client interface required by `runSkillLearn`.
+ *
+ * Decouples the CLI function from the concrete `WorkerClient`
+ * implementation, making it straightforward to test with mocks.
+ */
+export interface SkillLearnClient {
+    /**
+     * Stores a skill section in the knowledge base.
+     *
+     * @param params - section type, serialized JSON content,
+     *   and optional title and description
+     * @returns result containing the assigned kbid
+     */
+    addSection(params: {
+        readonly sectionType: string;
+        readonly content: string;
+        readonly title?: string;
+        readonly description?: string;
+    }): Promise<AddSectionResult>;
+}
+/**
+ * Creates or updates a skill definition in the knowledge base.
+ *
+ * Validates that `--name` and `--body` are provided, extracts
+ * `{{argName}}` placeholders from the body, serializes the skill
+ * to JSON, and stores it as a `'skill'` section.
+ *
+ * @param client - client used to store the skill section
+ * @param options - parsed CLI options with `name` and `body` fields
+ * @returns a `CommandResult` with the stored section info or an error
+ */
+export declare function runSkillLearn(client: SkillLearnClient, options: CliOptions): Promise<CommandResult>;

package/dist/src/shared/cli/functions/run-skill-list.function.d.ts

@@ -0,0 +1,43 @@
+import type { CliOptions } from '../typings/cli-options.interface.ts';
+import type { CommandResult } from '../typings/command-result.model.ts';
+/**
+ * A single row returned by `listByType` for the skill client.
+ */
+interface SkillRecord {
+    /** Knowledge-base identifier for the skill section. */
+    kbid: string;
+    /** Skill name stored as the section title. */
+    title: string | null;
+    /** Optional skill description stored on the section. */
+    description: string | null;
+    /** Serialized `SkillDefinition` JSON stored as section content. */
+    content: string;
+}
+/**
+ * Minimal client interface required by `runSkillList`.
+ *
+ * Decouples the CLI function from the concrete `WorkerClient`
+ * implementation, making it straightforward to test with mocks.
+ */
+export interface SkillListClient {
+    /**
+     * Retrieves all sections stored with the given type name.
+     *
+     * @param sectionType - the type name to filter by
+     * @returns matching section rows
+     */
+    listByType(sectionType: string): Promise<SkillRecord[]>;
+}
+/**
+ * Lists all skill definitions stored in the knowledge base.
+ *
+ * Calls `client.listByType('skill')` and maps each record to a
+ * summary that includes the argument count parsed from the JSON
+ * content. Parse errors default the argument count to `0`.
+ *
+ * @param client - client used to list skill sections
+ * @param _options - parsed CLI options (unused; reserved for future flags)
+ * @returns a `CommandResult` containing a JSON array of skill summaries
+ */
+export declare function runSkillList(client: SkillListClient, _options: CliOptions): Promise<CommandResult>;
+export {};

package/dist/src/shared/cli/functions/run-status.function.d.ts

@@ -0,0 +1,22 @@
+import type { CliOptions } from '../typings/cli-options.interface.ts';
+/**
+ * Minimal client interface required by `runStatus`.
+ *
+ * Decouples the CLI function from the concrete `WorkerClient`
+ * implementation, making it straightforward to test with mocks.
+ */
+export interface StatusClient {
+    dbStatus(): Promise<unknown>;
+}
+/**
+ * Retrieves the database status and returns the summary report.
+ *
+ * Delegates to `client.dbStatus()`. The caller is responsible
+ * for serialising the result and setting the process exit code.
+ *
+ * @param client - status client to delegate to
+ * @param _options - parsed CLI options (unused; reserved for
+ *   future flags)
+ * @returns the status report from the daemon
+ */
+export declare function runStatus(client: StatusClient, _options: CliOptions): Promise<unknown>;

package/dist/src/shared/cli/functions/run-unlearn.function.d.ts

@@ -0,0 +1,45 @@
+import type { CliOptions } from '../typings/cli-options.interface.ts';
+/** Removal result returned by `UnlearnClient.removeSection`. */
+interface RemoveSectionResult {
+    /** `true` when the section was found and successfully removed. */
+    readonly removed: boolean;
+    /** Time taken to perform the removal, in milliseconds. */
+    readonly elapsed_ms: number;
+}
+/**
+ * Minimal client interface required by `runUnlearn`.
+ *
+ * Decouples the CLI function from the concrete `WorkerClient`
+ * implementation, making it straightforward to test with mocks.
+ */
+export interface UnlearnClient {
+    /**
+     * Removes a section from the knowledge base.
+     *
+     * @param kbid - identifier of the section to remove
+     * @returns removal result with `removed` flag and elapsed time
+     */
+    removeSection(kbid: string): Promise<RemoveSectionResult>;
+}
+/** Result record produced for each kbid processed by the unlearn command. */
+export interface UnlearnResult {
+    /** Knowledge-base identifier that was targeted for removal. */
+    kbid: string;
+    /** `true` when the section was found and successfully removed. */
+    removed: boolean;
+}
+/**
+ * Removes the knowledge-base sections identified by `options.args`
+ * via the provided client.
+ *
+ * Each kbid in `options.args` is processed independently. If a kbid
+ * does not exist in the knowledge base, `removed` is set to `false`
+ * rather than throwing.
+ *
+ * @param client - unlearn client to delegate removal to
+ * @param options - parsed CLI options whose `args` list the kbids to
+ *   remove
+ * @returns one `UnlearnResult` per kbid processed
+ */
+export declare function runUnlearn(client: UnlearnClient, options: CliOptions): Promise<UnlearnResult[]>;
+export {};

package/dist/src/shared/cli/index.d.ts

@@ -0,0 +1,35 @@
+export { parseArgs } from './functions/parse-args.function.ts';
+export { formatOutput } from './functions/format-output.function.ts';
+export { runSearch } from './functions/run-search.function.ts';
+export { runLearn } from './functions/run-learn.function.ts';
+export { runUnlearn } from './functions/run-unlearn.function.ts';
+export { runContent } from './functions/run-content.function.ts';
+export { runCheck } from './functions/run-check.function.ts';
+export { runGc } from './functions/run-gc.function.ts';
+export { runRebuild } from './functions/run-rebuild.function.ts';
+export { ensureDb } from './functions/ensure-db.function.ts';
+export { findDb } from './functions/find-db.function.ts';
+export { runInit } from './functions/run-init.function.ts';
+export { runMigrate } from './functions/run-migrate.function.ts';
+export { errorToMessage } from './functions/error-to-message.function.ts';
+export { isStdinTty } from './functions/is-stdin-tty.function.ts';
+export { promptUser } from './functions/prompt-user.function.ts';
+export { dispatchCommand } from './functions/dispatch-command.function.ts';
+export { runCli } from './functions/run-cli.function.ts';
+export { HELP_TEXT } from './constants/help-text.constant.ts';
+export type { CliOptions, OutputFormat, SearchMode, } from './typings/cli-options.interface.ts';
+export type { LearnResult } from './typings/learn-result.model.ts';
+export type { SearchDisplay } from './typings/search-display.model.ts';
+export type { SearchClient } from './functions/run-search.function.ts';
+export type { LearnClient } from './functions/run-learn.function.ts';
+export type { UnlearnClient, UnlearnResult, } from './functions/run-unlearn.function.ts';
+export type { ContentClient } from './functions/run-content.function.ts';
+export type { CheckClient } from './functions/run-check.function.ts';
+export type { GcClient } from './functions/run-gc.function.ts';
+export type { RebuildClient } from './functions/run-rebuild.function.ts';
+export type { InitResult } from './functions/run-init.function.ts';
+export type { MigrateClient, MigrateCommandResult, } from './functions/run-migrate.function.ts';
+export type { CommandResult } from './typings/command-result.model.ts';
+export type { PromptIO } from './functions/prompt-user.function.ts';
+export type { DispatchClient } from './functions/dispatch-command.function.ts';
+export type { CliDeps, DisconnectableClient, } from './functions/run-cli.function.ts';

package/dist/src/shared/cli/typings/cli-options.interface.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Supported output formats for CLI results.
+ *
+ * - `'json'` -- machine-readable JSON array
+ * - `'text'` -- human-readable numbered list
+ * - `'mcp'` -- JSON envelope for MCP protocol consumers
+ */
+export type OutputFormat = 'json' | 'text' | 'mcp';
+/**
+ * Controls which entity type is returned by a search query.
+ *
+ * - `'sections'` -- individual content sections (default)
+ * - `'documents'` -- document-level groupings
+ * - `'stats'` -- index statistics
+ */
+export type SearchMode = 'sections' | 'documents' | 'stats';
+/** Parsed representation of all CLI arguments for a single invocation. */
+export interface CliOptions {
+    /** The sub-command to execute (e.g. `'search'`, `'learn'`). */
+    command: string;
+    /**
+     * Path to the knowledge-base root directory.
+     * Defaults to the current working directory when omitted.
+     */
+    dbPath?: string;
+    /** Output format for results. Defaults to `'json'`. */
+    format: OutputFormat;
+    /** Search mode passed to the worker daemon. Defaults to `'sections'`. */
+    mode: SearchMode;
+    /** Maximum number of results to return. Defaults to 20. */
+    limit: number;
+    /** Section title for learn command. */
+    title?: string;
+    /** Section description for learn command. */
+    description?: string;
+    /** Document ID for learn command. */
+    docid?: string;
+    /**
+     * When `true`, hydrates each search result's `preview` field
+     * with the section's actual content via `client.content()`.
+     */
+    content?: boolean;
+    /** Skill or agent name for skill/agent commands. */
+    name?: string;
+    /** Agent persona content or file path. */
+    persona?: string;
+    /** Skill body content or file path. */
+    body?: string;
+    /** Comma-separated skill kbids for agent create. */
+    skills?: string[];
+    /** Positional arguments following the sub-command. */
+    args: string[];
+}

package/dist/src/shared/cli/typings/command-result.model.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Result of dispatching a CLI command.
+ *
+ * Encapsulates output, error text, and exit code so the
+ * caller can decide how to present them (console, MCP, etc.)
+ * without the dispatch function touching process globals.
+ */
+export interface CommandResult {
+    /** Text to write to stdout (if any). */
+    output?: string;
+    /** Error message to write to stderr (if any). */
+    error?: string;
+    /** Process exit code. `0` means success. */
+    exitCode: number;
+}

package/dist/src/shared/cli/typings/learn-result.model.d.ts

@@ -0,0 +1,11 @@
+/** Result record produced for each file processed by the learn command. */
+export interface LearnResult {
+    /** Knowledge-base identifier assigned to the ingested section. */
+    kbid: string;
+    /** Absolute path to the source file that was ingested. */
+    path: string;
+    /** Size of the file content in bytes (UTF-8 character count). */
+    size: number;
+    /** `true` when the file was skipped without being ingested. */
+    skipped: boolean;
+}

package/dist/src/shared/cli/typings/search-display.model.d.ts

@@ -0,0 +1,17 @@
+/** A single search result formatted for display to the user. */
+export interface SearchDisplay {
+    /** Knowledge-base identifier of the matched section. */
+    kbid: string;
+    /** Relevance score assigned by the ranking engine. */
+    score: number;
+    /**
+     * Short excerpt from the section content.
+     * Empty string when no preview text is available.
+     */
+    preview: string;
+    /** Terms that matched within this section and their frequencies. */
+    readonly matches: readonly {
+        readonly term: string;
+        readonly frequency: number;
+    }[];
+}

package/dist/src/shared/dir-resolver/functions/resolve-base-dir.function.d.ts

@@ -0,0 +1,3 @@
+import type { BaseDir } from '../typings/base-dir.interface.ts';
+export declare function resolveScriptDir(entryUrl: string, entryDirname?: string): string;
+export declare function resolveBaseDir(entryUrl: string, entryDirname?: string): BaseDir;

package/dist/src/shared/dir-resolver/functions/resolve-wasm-dir.function.d.ts

@@ -0,0 +1 @@
+export declare function resolveWasmDir(scriptDir: string): string;

package/dist/src/shared/dir-resolver/functions/resolve-worker-script.function.d.ts

@@ -0,0 +1,2 @@
+import type { Runtime } from '../../runtime/typings/runtime.ts';
+export declare function resolveWorkerScript(scriptDir: string, runtime: Runtime): string;

package/dist/src/shared/dir-resolver/index.d.ts

@@ -0,0 +1,4 @@
+export { resolveBaseDir, resolveScriptDir, } from './functions/resolve-base-dir.function.ts';
+export { resolveWorkerScript } from './functions/resolve-worker-script.function.ts';
+export { resolveWasmDir } from './functions/resolve-wasm-dir.function.ts';
+export type { BaseDir } from './typings/base-dir.interface.ts';

package/dist/src/shared/dir-resolver/typings/base-dir.interface.d.ts

@@ -0,0 +1,4 @@
+export interface BaseDir {
+    readonly scriptDir: string;
+    readonly cwd: string;
+}

package/dist/src/shared/hash/functions/compute-sha256.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Computes the SHA-256 hash of a UTF-8 string.
+ *
+ * Uses the Web Crypto API (`crypto.subtle`), which is available
+ * in both Deno and Node.js >= 20 without additional imports.
+ *
+ * @param input - the string to hash
+ * @returns lowercase hex-encoded SHA-256 digest (64 characters)
+ */
+export declare function computeSha256(input: string): Promise<string>;

package/dist/src/shared/hash/index.d.ts

@@ -0,0 +1 @@
+export { computeSha256 } from './functions/compute-sha256.ts';

package/dist/src/shared/mcp/classes/mcp-server.class.d.ts

@@ -0,0 +1,55 @@
+import type { McpWorkerClient } from '../typings/mcp-client.interface.ts';
+import type { McpResponse } from '../typings/mcp-types.interface.ts';
+import type { McpLogLevel } from '../typings/log-types.interface.ts';
+/**
+ * MCP server that speaks JSON-RPC 2.0 over stdio. Listens for
+ * newline-delimited requests on `process.stdin`, dispatches each
+ * to the appropriate knowledge-base operation via
+ * `McpWorkerClient`, and writes JSON-RPC responses to
+ * `process.stdout`.
+ */
+export declare class McpServer {
+    private readonly client;
+    private readonly contextPath;
+    private initialized;
+    private hostCapabilities;
+    private logLevel;
+    private readonly subscriptions;
+    private nextRequestId;
+    private readonly pendingRequests;
+    constructor(client: McpWorkerClient, contextPath?: string);
+    listen(): Promise<void>;
+    handleLineForTest(line: string): Promise<McpResponse | null>;
+    /**
+     * Sends a JSON-RPC notification (no `id`, no response
+     * expected) to stdout.
+     */
+    notify(method: string, params?: Record<string, unknown>): void;
+    /**
+     * Emits a log notification if the message severity meets or
+     * exceeds the configured log level threshold.
+     */
+    log(level: McpLogLevel, message: unknown, logger?: string): void;
+    /**
+     * Sends a JSON-RPC request to the host (server-to-client)
+     * and returns a Promise that resolves with the response
+     * result. Times out after 30 seconds.
+     */
+    sendRequest(method: string, params: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Requests the host to generate text via the sampling
+     * capability. Throws if the host did not advertise sampling
+     * support during initialization.
+     */
+    requestSampling(messages: {
+        role: string;
+        content: {
+            type: string;
+            text: string;
+        };
+    }[], maxTokens: number): Promise<unknown>;
+    private dispatchLine;
+    private processLine;
+    private handleRequest;
+    private send;
+}

package/dist/src/shared/mcp/constants/mcp-error-codes.constant.d.ts

@@ -0,0 +1,26 @@
+/**
+ * JSON-RPC 2.0 parse error code. Returned when the
+ * server receives malformed JSON.
+ */
+export declare const PARSE_ERROR = -32700;
+/**
+ * JSON-RPC 2.0 method not found error code. Returned
+ * when the requested method does not exist.
+ */
+export declare const METHOD_NOT_FOUND = -32601;
+/**
+ * JSON-RPC 2.0 invalid params error code. Returned
+ * when method parameters are invalid or missing.
+ */
+export declare const INVALID_PARAMS = -32602;
+/**
+ * JSON-RPC 2.0 internal error code. Returned when an
+ * unexpected server-side error occurs.
+ */
+export declare const INTERNAL_ERROR = -32603;
+/**
+ * MCP-specific resource not found error code. Returned
+ * when a well-formed URI does not match any resource
+ * in the knowledge base.
+ */
+export declare const RESOURCE_NOT_FOUND = -32002;

package/dist/src/shared/mcp/functions/create-mcp-server.function.d.ts

@@ -0,0 +1,11 @@
+import { McpServer } from '../classes/mcp-server.class.ts';
+import type { McpWorkerClient } from '../typings/mcp-client.interface.ts';
+/**
+ * Factory that constructs a new `McpServer` bound to the given
+ * worker client. Call `server.listen()` on the returned instance
+ * to start processing stdio input.
+ *
+ * @param client - worker client providing knowledge-base operations
+ * @returns a configured `McpServer` ready to listen
+ */
+export declare function createMcpServer(client: McpWorkerClient): McpServer;