@totemsdk/mcp-server 0.2.0 → 0.4.0

package/dist/index-store.d.ts

@@ -0,0 +1,18 @@
+import type { SdkIndex } from './types.js';
+export type IndexState = {
+    readonly ok: true;
+    readonly index: SdkIndex;
+} | {
+    readonly ok: false;
+    readonly error: string;
+};
+/**
+ * Lazily-built, process-wide SDK index state. Never throws: an unavailable
+ * index is cached as an error so every call site can return an honest failure
+ * instead of an empty (confidently-wrong) index.
+ */
+export declare function getIndexState(): IndexState;
+/** The SDK index, or throws {@link IndexUnavailableError} when unavailable. */
+export declare function getIndex(): SdkIndex;
+/** Rebuild the SDK index from the filesystem (used by the `refresh-index` tool). */
+export declare function refreshIndex(): SdkIndex;

package/dist/index-store.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIndexState = getIndexState;
+exports.getIndex = getIndex;
+exports.refreshIndex = refreshIndex;
+const indexer_js_1 = require("./indexer.js");
+let _state = null;
+/**
+ * Lazily-built, process-wide SDK index state. Never throws: an unavailable
+ * index is cached as an error so every call site can return an honest failure
+ * instead of an empty (confidently-wrong) index.
+ */
+function getIndexState() {
+    if (_state)
+        return _state;
+    try {
+        _state = { ok: true, index: (0, indexer_js_1.buildIndex)() };
+    }
+    catch (e) {
+        _state = {
+            ok: false,
+            error: e instanceof Error ? e.message : String(e),
+        };
+    }
+    return _state;
+}
+/** The SDK index, or throws {@link IndexUnavailableError} when unavailable. */
+function getIndex() {
+    const state = getIndexState();
+    if (!state.ok)
+        throw new indexer_js_1.IndexUnavailableError(state.error);
+    return state.index;
+}
+/** Rebuild the SDK index from the filesystem (used by the `refresh-index` tool). */
+function refreshIndex() {
+    _state = null;
+    return getIndex();
+}

package/dist/index.d.ts

@@ -1,12 +1,15 @@
-import type { SdkIndex } from './types.js';
-declare const index: SdkIndex;
+#!/usr/bin/env node
 export declare const SERVER_INFO: {
     readonly name: "@totemsdk/mcp-server";
-    readonly version: "0.2.0";
+    readonly version: string;
     readonly capabilities: {
         readonly resources: {};
         readonly tools: {};
         readonly prompts: {};
     };
 };
-export { index as sdkIndex };
+/**
+ * @deprecated Importing this at module load forces index construction. Prefer
+ * `getIndexState()`/`getIndex()` so a missing index is handled, not thrown.
+ */
+export declare const sdkIndex: import("./types.js").SdkIndex;

package/dist/index.js

@@ -1,134 +1,106 @@
+#!/usr/bin/env node
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sdkIndex = exports.SERVER_INFO = void 0;
 const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
-const indexer_js_1 = require("./indexer.js");
+const index_store_js_1 = require("./index-store.js");
 const resources_js_1 = require("./resources.js");
 const tools_js_1 = require("./tools.js");
-const index = (0, indexer_js_1.buildIndex)();
-exports.sdkIndex = index;
-const server = new index_js_1.Server({ name: '@totemsdk/mcp-server', version: '0.1.0' }, { capabilities: { resources: {}, tools: {}, prompts: {} } });
-server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => ({
-    resources: (0, resources_js_1.listResources)(index),
-}));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function readPkgVersion() {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf-8')).version || '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+const server = new index_js_1.Server({ name: '@totemsdk/mcp-server', version: readPkgVersion() }, { capabilities: { resources: {}, tools: {}, prompts: {} } });
+server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => {
+    const state = (0, index_store_js_1.getIndexState)();
+    // Still advertise resources when the index is unavailable so clients see the
+    // server is alive; reads then fail with an actionable message.
+    return { resources: (0, resources_js_1.listResources)(state.ok ? state.index : {}) };
+});
 server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) => {
     const { uri } = request.params;
-    const text = (0, resources_js_1.handleResourceRead)(uri, index);
+    const state = (0, index_store_js_1.getIndexState)();
+    if (!state.ok) {
+        throw new Error(`Resource unavailable: ${state.error}`);
+    }
+    const text = (0, resources_js_1.handleResourceRead)(uri, state.index);
     if (text === null) {
         throw new Error(`Resource not found: ${uri}`);
     }
-    return { contents: [{ uri, mimeType: 'text/plain', text }] };
+    return { contents: [{ uri, mimeType: (0, resources_js_1.resourceMimeType)(uri), text }] };
 });
 server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
-    tools: [
-        {
-            name: 'search-symbol',
-            description: 'Search for a symbol (function, type, class) across all packages',
-            inputSchema: {
-                type: 'object',
-                properties: { query: { type: 'string', description: 'Partial symbol name to search' } },
-                required: ['query'],
-            },
-        },
-        {
-            name: 'find-type',
-            description: 'Find type definitions (interfaces, classes, type aliases) matching a pattern',
-            inputSchema: {
-                type: 'object',
-                properties: { pattern: { type: 'string', description: 'Type name pattern to search' } },
-                required: ['pattern'],
-            },
-        },
-        {
-            name: 'dependency-graph',
-            description: 'Get dependency graph for a package — inbound dependents or outbound dependencies',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    package: { type: 'string', description: 'Package name (e.g. @totemsdk/edge-opcua)' },
-                    direction: { type: 'string', enum: ['in', 'out', 'all'], description: 'Dependency direction' },
-                },
-                required: ['package'],
-            },
-        },
-        {
-            name: 'validate-import',
-            description: 'Check whether a cross-package import is valid',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    from: { type: 'string', description: 'Source package name' },
-                    to: { type: 'string', description: 'Target package name' },
-                    symbol: { type: 'string', description: 'Optional: specific symbol to check' },
-                },
-                required: ['from', 'to'],
-            },
-        },
-        {
-            name: 'scaffold-adapter',
-            description: 'Generate boilerplate for a new edge protocol adapter',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    name: { type: 'string', description: 'Package name suffix' },
-                    protocol: { type: 'string', description: 'Protocol name (PascalCase)' },
-                    commands: { type: 'array', items: { type: 'string' }, description: 'Transport port methods' },
-                },
-                required: ['name', 'protocol'],
-            },
-        },
-        {
-            name: 'scaffold-package',
-            description: 'Generate boilerplate for a new @totemsdk package',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    name: { type: 'string', description: 'Package name (without @totemsdk/ prefix)' },
-                    deps: { type: 'array', items: { type: 'string' }, description: 'Dependency package names' },
-                },
-                required: ['name'],
-            },
-        },
-        {
-            name: 'package-stats',
-            description: 'Get statistics about a package — export counts, Rust/Go, tests, deps',
-            inputSchema: {
-                type: 'object',
-                properties: { name: { type: 'string', description: 'Package name' } },
-                required: ['name'],
-            },
-        },
-        {
-            name: 'list-exports',
-            description: 'List exports of a package',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    package: { type: 'string', description: 'Package name' },
-                    kind: { type: 'string', enum: ['function', 'type', 'interface', 'class', 'const', ''], description: 'Filter by export kind' },
-                    filter: { type: 'string', description: 'Filter by name substring' },
-                },
-                required: ['package'],
-            },
-        },
-        {
-            name: 'suggest-template',
-            description: 'Suggest KISSVM script templates matching a use case — describes what you want to do and returns matching templates with import paths',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    usecase: { type: 'string', description: 'Describe what you want to do (e.g. "time-lock funds until a block height", "vote tally with quorum", "identity verification")' },
-                },
-                required: ['usecase'],
-            },
-        },
-    ],
+    tools: tools_js_1.TOOL_DEFINITIONS,
 }));
+/**
+ * Tools that read the SDK index. The rest (scaffolding, template suggestions)
+ * work without it, so a missing index degrades honestly instead of failing
+ * everything.
+ */
+const INDEX_REQUIRED_TOOLS = new Set([
+    'search-symbol',
+    'find-type',
+    'dependency-graph',
+    'validate-import',
+    'package-stats',
+    'list-exports',
+    'read-source',
+    'list-packages',
+    'search-packages',
+    'refresh-index',
+]);
 server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
-    return (0, tools_js_1.handleToolCall)(name, args || {}, index);
+    const state = (0, index_store_js_1.getIndexState)();
+    if (!state.ok && INDEX_REQUIRED_TOOLS.has(name)) {
+        return {
+            content: [{ type: 'text', text: `SDK index unavailable: ${state.error}` }],
+            isError: true,
+        };
+    }
+    // Index-free tools ignore the index argument; pass the real one when present.
+    return (0, tools_js_1.handleToolCall)(name, args || {}, state.ok ? state.index : {});
 });
 server.setRequestHandler(types_js_1.ListPromptsRequestSchema, async () => ({
     prompts: [
@@ -151,6 +123,11 @@ server.setRequestHandler(types_js_1.ListPromptsRequestSchema, async () => ({
 }));
 server.setRequestHandler(types_js_1.GetPromptRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
+    const indexState = (0, index_store_js_1.getIndexState)();
+    if (!indexState.ok) {
+        throw new Error(`SDK index unavailable: ${indexState.error}`);
+    }
+    const index = indexState.index;
     if (name === 'analyze-cross-package') {
         const from = args?.from;
         const to = args?.to;
@@ -224,9 +201,17 @@ server.setRequestHandler(types_js_1.GetPromptRequestSchema, async (request) => {
 });
 exports.SERVER_INFO = {
     name: '@totemsdk/mcp-server',
-    version: '0.2.0',
+    version: readPkgVersion(),
     capabilities: { resources: {}, tools: {}, prompts: {} },
 };
+/**
+ * @deprecated Importing this at module load forces index construction. Prefer
+ * `getIndexState()`/`getIndex()` so a missing index is handled, not thrown.
+ */
+exports.sdkIndex = (() => {
+    const state = (0, index_store_js_1.getIndexState)();
+    return state.ok ? state.index : { generatedAt: 0, packages: {}, symbolIndex: {}, domainMap: {} };
+})();
 async function main() {
     const transport = new stdio_js_1.StdioServerTransport();
     await server.connect(transport);

package/dist/indexer.d.ts

@@ -1,3 +1,29 @@
 import type { SdkIndex } from './types.js';
-export declare function buildIndex(): SdkIndex;
+/**
+ * Thrown when no SDK index can be produced — neither a monorepo to scan nor a
+ * bundled index shipped in the package. Callers must surface this as an error,
+ * never as an empty (and therefore confidently-wrong) index.
+ */
+export declare class IndexUnavailableError extends Error {
+    constructor(message: string);
+}
+export interface BuildIndexOptions {
+    /**
+     * Monorepo root to scan. Use `null` to force the non-monorepo path (bundled
+     * index or an error). Defaults to auto-detection.
+     */
+    rootDir?: string | null;
+    /** Never fall back to the bundled index (used by tests / strict callers). */
+    noBundled?: boolean;
+}
+/** Scan a monorepo root into an `SdkIndex`. */
+export declare function buildFromMonorepo(root: string, now?: number): SdkIndex;
+/**
+ * Build the SDK index. Prefers a live monorepo scan; falls back to the bundled
+ * index shipped in the package. Throws {@link IndexUnavailableError} when
+ * neither is available — an empty index is never returned, because downstream
+ * tools would otherwise answer "not found" as if it were fact.
+ */
+export declare function buildIndex(options?: BuildIndexOptions): SdkIndex;
+/** Read a file from a package's `src/` directory (for the `read-source` tool). */
 export declare function readSourceFile(pkgName: string, filePath: string): string | null;