@totemsdk/mcp-server 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Totem SDK Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,69 @@
+# @totemsdk/mcp-server
+
+Model Context Protocol server exposing the full Totem SDK package set — 53 packages, 13k+ exports, cross-package dependency graphs, and scaffolding tools.
+
+## Usage
+
+### Claude Desktop
+
+Add to `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "totemsdk": {
+      "command": "npx",
+      "args": ["-y", "@totemsdk/mcp-server"]
+    }
+  }
+}
+```
+
+### Any MCP client
+
+```bash
+npx -y @totemsdk/mcp-server
+```
+
+The server runs on stdio and communicates via JSON-RPC.
+
+## Resources
+
+| URI | Description |
+|-----|-------------|
+| `totemsdk://packages` | All packages with metadata |
+| `totemsdk://packages/{name}` | Package metadata (deps, exports, domain) |
+| `totemsdk://packages/{name}/exports` | Exported symbols |
+| `totemsdk://packages/{name}/dependencies` | Dependency lists |
+| `totemsdk://packages/by-domain/{layer}` | Packages in a domain |
+| `totemsdk://conventions` | Coding conventions |
+| `totemsdk://domain-map` | Packages grouped by domain |
+| `totemsdk://symbol/{name}` | Symbol locations across packages |
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `search-symbol` | Find which packages export a symbol |
+| `find-type` | Locate type definitions by name pattern |
+| `dependency-graph` | Get outbound deps or inbound dependents |
+| `validate-import` | Check if a cross-package import is valid |
+| `scaffold-adapter` | Generate edge protocol adapter boilerplate |
+| `scaffold-package` | Generate new package boilerplate |
+| `package-stats` | Export counts, Rust/Go, tests, deps |
+| `list-exports` | List exports filtered by kind and name |
+
+## Prompts
+
+| Prompt | Description |
+|--------|-------------|
+| `analyze-cross-package` | Compare two packages' relationship |
+| `new-edge-adapter` | Walk through creating a protocol adapter |
+
+## How it works
+
+At startup, the server scans all `@totemsdk/*` packages in the monorepo, parses `package.json` and `src/index.ts` to build an in-memory index of 53 packages and their exports. No runtime dependency on any `@totemsdk/*` package.
+
+## License
+
+MIT

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 resources_js_1 = require("./resources.js");
+const tools_js_1 = require("./tools.js");
+const index = (0, indexer_js_1.buildIndex)();
+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),
+}));
+server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    const text = (0, resources_js_1.handleResourceRead)(uri, index);
+    if (text === null) {
+        throw new Error(`Resource not found: ${uri}`);
+    }
+    return { contents: [{ uri, mimeType: 'text/plain', 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'],
+            },
+        },
+    ],
+}));
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    return (0, tools_js_1.handleToolCall)(name, args || {}, index);
+});
+server.setRequestHandler(types_js_1.ListPromptsRequestSchema, async () => ({
+    prompts: [
+        {
+            name: 'analyze-cross-package',
+            description: 'Analyze relationships and dependencies between two packages',
+            arguments: [
+                { name: 'from', description: 'First package name', required: true },
+                { name: 'to', description: 'Second package name', required: true },
+            ],
+        },
+        {
+            name: 'new-edge-adapter',
+            description: 'Walk through creating a new edge protocol adapter step by step',
+            arguments: [
+                { name: 'protocol', description: 'Protocol name (e.g. MQTT, OPC-UA)', required: true },
+            ],
+        },
+    ],
+}));
+server.setRequestHandler(types_js_1.GetPromptRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    if (name === 'analyze-cross-package') {
+        const from = args?.from;
+        const to = args?.to;
+        const fromPkg = from ? index.packages[from] : null;
+        const toPkg = to ? index.packages[to] : null;
+        if (!fromPkg || !toPkg) {
+            throw new Error(`Packages not found: ${!fromPkg ? from : ''} ${!toPkg ? to : ''}`);
+        }
+        const dependsOn = fromPkg.dependencies.includes(to);
+        const dependedBy = toPkg.dependencies.includes(from);
+        const fromExports = Object.entries(fromPkg.exports).flatMap(([k, v]) => v.map((s) => `${s} (${k})`));
+        const toExports = Object.entries(toPkg.exports).flatMap(([k, v]) => v.map((s) => `${s} (${k})`));
+        const lines = [
+            `Analyze the relationship between **${from}** and **${to}**:`,
+            '',
+            `| | ${from} | ${to} |`,
+            `|---|---|---|`,
+            `| Version | ${fromPkg.version} | ${toPkg.version} |`,
+            `| Domain | ${fromPkg.domain} | ${toPkg.domain} |`,
+            `| Has Rust | ${fromPkg.hasRust} | ${toPkg.hasRust} |`,
+            `| Has Go | ${fromPkg.hasGo} | ${toPkg.hasGo} |`,
+            `| Tests | ${fromPkg.hasTests} | ${toPkg.hasTests} |`,
+            `| Exports | ${fromExports.length} | ${toExports.length} |`,
+            '',
+            `**Dependency direction:** ${from} \u2192 ${to}: ${dependsOn ? 'Yes' : 'No'}`,
+            `${to} \u2192 ${from}: ${dependedBy ? 'Yes' : 'No'}`,
+            '',
+            dependsOn ? `**${from}** depends on **${to}**.` : '',
+            dependedBy ? `**${to}** depends on **${from}**.` : '',
+            !dependsOn && !dependedBy ? 'These packages have no direct dependency relationship.' : '',
+            '',
+            `**${from}** exports: ${fromExports.join(', ')}`,
+            '',
+            `**${to}** exports: ${toExports.join(', ')}`,
+        ];
+        return {
+            messages: [{ role: 'user', content: { type: 'text', text: lines.filter(Boolean).join('\n') } }],
+        };
+    }
+    if (name === 'new-edge-adapter') {
+        const protocol = args?.protocol || 'UnknownProtocol';
+        const existingAdapters = Object.values(index.packages).filter(p => p.domain === 'edge/protocols' && p.dir.startsWith('edge-'));
+        const lines = [
+            `You are scaffolding a new **${protocol}** edge protocol adapter for Totem SDK.`,
+            '',
+            `**Reference:** ${existingAdapters.length} existing protocol adapters:`,
+            ...existingAdapters.map(p => `  - **${p.name}** — ${p.description}`),
+            '',
+            '**Required pattern for all edge adapters:**',
+            `1. Zero runtime protocol dependencies — inject via \`${protocol}TransportPort\``,
+            `2. Export \`create${protocol}Gateway\` and \`create${protocol}SensorBridge\` factory functions`,
+            `3. Export \`${protocol}TransportPort\` interface for users to implement`,
+            `4. Export gateway, sensor bridge, and binding config types`,
+            `5. Depend only on \`@totemsdk/edge\``,
+            '',
+            '**Files to create:**',
+            `- \`src/transport.ts\` — \`${protocol}TransportPort\` interface`,
+            `- \`src/gateway.ts\` — gateway factory with config type`,
+            `- \`src/sensor-bridge.ts\` — sensor bridge factory with binding config`,
+            `- \`src/index.ts\` — barrel exports`,
+            `- \`package.json\` — \`@totemsdk/edge-${protocol.toLowerCase()}\` with \`@totemsdk/edge\` dep`,
+            '- `tsconfig.json` — standard Totem SDK config',
+            '',
+            'Use the `scaffold-adapter` tool to generate the boilerplate, then fill in the protocol-specific logic.',
+        ];
+        return {
+            messages: [{ role: 'user', content: { type: 'text', text: lines.join('\n') } }],
+        };
+    }
+    throw new Error(`Prompt not found: ${name}`);
+});
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error('@totemsdk/mcp-server running on stdio');
+}
+main().catch((err) => {
+    console.error('Fatal error:', err);
+    process.exit(1);
+});

package/dist/indexer.d.ts

@@ -0,0 +1,3 @@
+import type { SdkIndex } from './types.js';
+export declare function buildIndex(): SdkIndex;
+export declare function readSourceFile(pkgName: string, filePath: string): string | null;

package/dist/indexer.js

@@ -0,0 +1,221 @@
+"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.buildIndex = buildIndex;
+exports.readSourceFile = readSourceFile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const REPO_ROOT = path.resolve(__dirname, '..', '..', '..', '..', '..', '..');
+const PKG_DIR = path.join(REPO_ROOT, 'packages', 'totem-sdk', 'packages');
+const TOP_PKG_DIR = path.join(REPO_ROOT, 'packages');
+const DOMAIN_GROUPS = [
+    [/^core-wasm$|^core$|^txpow$|^kissvm$/, 'core/crypto'],
+    [/^identity$|^root-identity$|^authority$|^proof$|^proof-integritas$|^proofgraph$|^manifest$/, 'identity/authority'],
+    [/^governance$|^recursive-mast$/, 'governance'],
+    [/^edge$|^edge-adapters$|^industrial-action$|^agent-policy$/, 'edge/runtime'],
+    [/^edge-(bacnet|ble|can|coap|grpc|lorawan|matter|modbus|mqtt|opcua|ros2)$/, 'edge/protocols'],
+    [/^omnia(-factory|-router|-splice|-vtxo)?$/, 'blockchain/omnia'],
+    [/^statechain$|^tx-builder$|^chain-provider$|^wots-lease$|^liquidity-bond$|^provider-bond$/, 'blockchain/infra'],
+    [/^lookup-(client|node|protocol)$/, 'lookup/p2p'],
+    [/^stream-transport$|^pubsub-transport$|^pureminima-rpc$|^server$|^se-server$|^realtime$|^connect$|^wallet-adapter$|^pear$|^observability$/, 'utilities'],
+    [/^sdk-tests$/, 'testing'],
+];
+function classifyDomain(dirName) {
+    for (const [pattern, domain] of DOMAIN_GROUPS) {
+        if (pattern.test(dirName))
+            return domain;
+    }
+    return 'other';
+}
+function findPackageDirs() {
+    const dirs = [];
+    for (const base of [PKG_DIR, TOP_PKG_DIR]) {
+        if (!fs.existsSync(base))
+            continue;
+        for (const entry of fs.readdirSync(base, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const pj = path.join(base, entry.name, 'package.json');
+            if (fs.existsSync(pj))
+                dirs.push(path.join(base, entry.name));
+        }
+    }
+    return dirs.sort();
+}
+function readPackageJson(dir) {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function hasSubdir(dir, name) {
+    const d = path.join(dir, name);
+    return fs.existsSync(d) && fs.statSync(d).isDirectory();
+}
+function hasTestDir(dir) {
+    const srcTest = path.join(dir, 'src', '__tests__');
+    const srcTestAlt = path.join(dir, 'src', 'test');
+    const testDir = path.join(dir, 'test');
+    const testsDir = path.join(dir, 'tests');
+    return [srcTest, srcTestAlt, testDir, testsDir].some(d => fs.existsSync(d));
+}
+function parseExports(dir, pkgName) {
+    const indexFiles = [
+        path.join(dir, 'src', 'index.ts'),
+        path.join(dir, 'src', 'index.js'),
+    ];
+    let content = '';
+    for (const f of indexFiles) {
+        if (fs.existsSync(f)) {
+            content = fs.readFileSync(f, 'utf-8');
+            break;
+        }
+    }
+    const exports = { functions: [], types: [], classes: [], interfaces: [], consts: [] };
+    if (!content)
+        return exports;
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        const fnMatch = trimmed.match(/^export (async )?function (\w+)/);
+        if (fnMatch) {
+            exports.functions.push(fnMatch[2]);
+            continue;
+        }
+        const typeMatch = trimmed.match(/^export type \{ ([^}]+) \}/);
+        if (typeMatch) {
+            typeMatch[1].split(',').map(s => s.trim()).filter(Boolean).forEach(s => {
+                const name = s.split(/\s+as\s+/).pop()?.trim() || s;
+                if (name)
+                    exports.types.push(name);
+            });
+            continue;
+        }
+        const clsMatch = trimmed.match(/^export class (\w+)/);
+        if (clsMatch) {
+            exports.classes.push(clsMatch[1]);
+            continue;
+        }
+        const ifaceMatch = trimmed.match(/^export interface (\w+)/);
+        if (ifaceMatch) {
+            exports.interfaces.push(ifaceMatch[1]);
+            continue;
+        }
+        const constMatch = trimmed.match(/^export (const|let|var) (\w+)/);
+        if (constMatch) {
+            exports.consts.push(constMatch[2]);
+            continue;
+        }
+        const namedExport = trimmed.match(/^export \{ ([^}]+) \}/);
+        if (namedExport) {
+            for (const part of namedExport[1].split(',')) {
+                const name = part.trim().split(/\s+as\s+/).pop()?.trim() || '';
+                if (name && !name.startsWith('type ') && name !== 'type') {
+                    if (name.endsWith('}'))
+                        continue;
+                    if (/^[A-Z]/.test(name))
+                        exports.types.push(name);
+                    else
+                        exports.functions.push(name);
+                }
+            }
+        }
+    }
+    return exports;
+}
+function buildIndex() {
+    const packages = {};
+    const symbolIndex = {};
+    const domainMap = {};
+    for (const dir of findPackageDirs()) {
+        const pkg = readPackageJson(dir);
+        if (!pkg || !pkg.name)
+            continue;
+        const dirName = path.basename(dir);
+        const deps = Object.keys(pkg.dependencies || {});
+        const devDeps = Object.keys(pkg.devDependencies || {});
+        const hasRust = hasSubdir(dir, 'rust') || hasSubdir(dir, 'rust-toolchain');
+        const hasGo = hasSubdir(dir, 'go');
+        const hasTests = hasTestDir(dir);
+        const exports = parseExports(dir, pkg.name);
+        const domain = classifyDomain(dirName);
+        const idx = {
+            name: pkg.name,
+            dir: dirName,
+            version: pkg.version || '0.0.0',
+            description: pkg.description || '',
+            dependencies: deps,
+            devDependencies: devDeps,
+            hasRust,
+            hasGo,
+            hasTests,
+            exports,
+            domain,
+        };
+        packages[pkg.name] = idx;
+        if (!domainMap[domain])
+            domainMap[domain] = [];
+        domainMap[domain].push(pkg.name);
+        const allExports = [];
+        for (const n of exports.functions)
+            allExports.push([n, 'function']);
+        for (const n of exports.types)
+            allExports.push([n, 'type']);
+        for (const n of exports.classes)
+            allExports.push([n, 'class']);
+        for (const n of exports.interfaces)
+            allExports.push([n, 'interface']);
+        for (const n of exports.consts)
+            allExports.push([n, 'const']);
+        for (const [name, kind] of allExports) {
+            if (!symbolIndex[name])
+                symbolIndex[name] = [];
+            symbolIndex[name].push({ package: pkg.name, kind });
+        }
+    }
+    return { generatedAt: Date.now(), packages, symbolIndex, domainMap };
+}
+function readSourceFile(pkgName, filePath) {
+    const relativePath = path.join('packages', 'totem-sdk', 'packages', pkgName, 'src', filePath);
+    const absPath = path.join(REPO_ROOT, relativePath);
+    const altPath = path.join(REPO_ROOT, 'packages', pkgName, 'src', filePath);
+    for (const p of [absPath, altPath]) {
+        if (fs.existsSync(p))
+            return fs.readFileSync(p, 'utf-8');
+    }
+    return null;
+}

package/dist/resources.d.ts

@@ -0,0 +1,7 @@
+import type { SdkIndex } from './types.js';
+export declare function handleResourceRead(uri: string, index: SdkIndex): string | null;
+export declare function listResources(index: SdkIndex): Array<{
+    uri: string;
+    name: string;
+    description: string;
+}>;

package/dist/resources.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleResourceRead = handleResourceRead;
+exports.listResources = listResources;
+const CONVENTIONS = `# Totem SDK Conventions
+
+## Package Structure
+- src/index.ts - barrel exports
+- src/types.ts - all type definitions
+- src/canonical.ts - canonicalJson, toHex, hashCanonical
+- src/ids.ts - ID computation (domain-prefixed SHA3-256)
+- src/errors.ts - error class hierarchy
+- src/__tests__/ - Jest tests
+
+## ID Format
+- totem:<package>:<kind>:<sha3-256-hex>
+- Example: totem:ia:proposal:<hex>, totem:gov:proposal:<hex>, edge:device:<hex>
+
+## Canonical JSON
+- Recursive deterministic JSON with sorted object keys
+- Used as input to all hashing and signing operations
+- Each package has its own canonicalJson() (no shared util)
+
+## Hashing
+- SHA3-256 via @totemsdk/core
+- Domain-prefixed: sha3-256(domain + canonicalJson(data))
+- Domain constants like 'TOTEM_GOVERNANCE_PROPOSAL_V1'
+
+## Signing
+- WOTS (Winternitz One-Time Signatures) via @totemsdk/core-wasm WASM
+- @totemsdk/wots-lease for key-use coordination
+
+## Error Handling
+- Hierarchical Error subclasses with code strings
+- EdgeOperationResult<T> = { ok: boolean, data?: T, error?: string, errorCode?: string }
+
+## Time
+- Unix milliseconds (Date.now())
+- Optional now parameter for determinism in testing
+
+## Validation
+- Custom guard functions returning string[]
+- No external schema libraries (no zod/io-ts/ajv)
+
+## Async
+- Promise<T> everywhere, typed event emitters, no Observables
+- Action lifecycle: propose -> reserve -> execute -> confirm/fail/unknown`;
+function handleResourceRead(uri, index) {
+    if (uri === 'totemsdk://packages') {
+        return JSON.stringify(Object.values(index.packages).map(p => ({
+            name: p.name,
+            version: p.version,
+            domain: p.domain,
+            description: p.description,
+            hasRust: p.hasRust,
+            hasGo: p.hasGo,
+            hasTests: p.hasTests,
+        })), null, 2);
+    }
+    if (uri === 'totemsdk://conventions')
+        return CONVENTIONS;
+    if (uri === 'totemsdk://domain-map') {
+        return JSON.stringify(index.domainMap, null, 2);
+    }
+    const pkgMatch = uri.match(/^totemsdk:\/\/packages\/([^/]+)$/);
+    if (pkgMatch) {
+        const pkg = index.packages[pkgMatch[1]];
+        return pkg ? JSON.stringify(pkg, null, 2) : null;
+    }
+    const pkgExportsMatch = uri.match(/^totemsdk:\/\/packages\/([^/]+)\/exports$/);
+    if (pkgExportsMatch) {
+        const pkg = index.packages[pkgExportsMatch[1]];
+        return pkg ? JSON.stringify(pkg.exports, null, 2) : null;
+    }
+    const pkgDepsMatch = uri.match(/^totemsdk:\/\/packages\/([^/]+)\/dependencies$/);
+    if (pkgDepsMatch) {
+        const pkg = index.packages[pkgDepsMatch[1]];
+        if (!pkg)
+            return null;
+        return JSON.stringify({ dependencies: pkg.dependencies, devDependencies: pkg.devDependencies }, null, 2);
+    }
+    const domainMatch = uri.match(/^totemsdk:\/\/packages\/by-domain\/(.+)$/);
+    if (domainMatch) {
+        const pkgs = index.domainMap[domainMatch[1]];
+        return pkgs ? JSON.stringify(pkgs.map(n => index.packages[n]).filter(Boolean), null, 2) : null;
+    }
+    const symbolMatch = uri.match(/^totemsdk:\/\/symbol\/(.+)$/);
+    if (symbolMatch) {
+        const entries = index.symbolIndex[symbolMatch[1]];
+        return entries ? JSON.stringify(entries, null, 2) : null;
+    }
+    return null;
+}
+function listResources(index) {
+    const resources = [
+        { uri: 'totemsdk://packages', name: 'All Packages', description: 'List of all 53 SDK packages with metadata' },
+        { uri: 'totemsdk://conventions', name: 'Coding Conventions', description: 'Totem SDK coding conventions and patterns' },
+        { uri: 'totemsdk://domain-map', name: 'Domain Map', description: 'Packages grouped by domain layer' },
+    ];
+    for (const [domain, pkgs] of Object.entries(index.domainMap)) {
+        resources.push({
+            uri: `totemsdk://packages/by-domain/${domain}`,
+            name: `Domain: ${domain}`,
+            description: `${pkgs.length} packages in ${domain}`,
+        });
+    }
+    for (const [name, pkg] of Object.entries(index.packages)) {
+        resources.push({
+            uri: `totemsdk://packages/${encodeURIComponent(name)}`,
+            name: `Package: ${name}`,
+            description: pkg.description,
+        });
+        resources.push({
+            uri: `totemsdk://packages/${encodeURIComponent(name)}/exports`,
+            name: `Exports: ${name}`,
+            description: `Exported symbols from ${name}`,
+        });
+        resources.push({
+            uri: `totemsdk://packages/${encodeURIComponent(name)}/dependencies`,
+            name: `Dependencies: ${name}`,
+            description: `Dependencies of ${name}`,
+        });
+    }
+    const topSymbols = Object.entries(index.symbolIndex)
+        .filter(([_, v]) => v.length <= 3)
+        .slice(0, 200);
+    for (const [symbol, entries] of topSymbols) {
+        resources.push({
+            uri: `totemsdk://symbol/${symbol}`,
+            name: `Symbol: ${symbol}`,
+            description: `Found in ${entries.map(e => e.package).join(', ')}`,
+        });
+    }
+    return resources;
+}

package/dist/tools.d.ts

@@ -0,0 +1,2 @@
+import type { SdkIndex, ToolResponse } from './types.js';
+export declare function handleToolCall(name: string, args: any, index: SdkIndex): ToolResponse;

package/dist/tools.js

@@ -0,0 +1,416 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleToolCall = handleToolCall;
+function handleToolCall(name, args, index) {
+    switch (name) {
+        case 'search-symbol': return searchSymbol(args, index);
+        case 'find-type': return findType(args, index);
+        case 'dependency-graph': return dependencyGraph(args, index);
+        case 'validate-import': return validateImport(args, index);
+        case 'scaffold-adapter': return scaffoldAdapter(args);
+        case 'scaffold-package': return scaffoldPackage(args);
+        case 'package-stats': return packageStats(args, index);
+        case 'list-exports': return listExports(args, index);
+        default: return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+    }
+}
+function searchSymbol(args, index) {
+    const query = (args.query || '').toLowerCase();
+    if (!query)
+        return { content: [{ type: 'text', text: 'query is required' }], isError: true };
+    const results = [];
+    for (const [symbol, entries] of Object.entries(index.symbolIndex)) {
+        if (symbol.toLowerCase().includes(query)) {
+            for (const entry of entries) {
+                results.push({ symbol, package: entry.package, kind: entry.kind });
+            }
+        }
+    }
+    results.sort((a, b) => a.symbol.localeCompare(b.symbol));
+    if (results.length === 0) {
+        return { content: [{ type: 'text', text: `No symbols found matching '${query}'` }] };
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: `Found ${results.length} match(es) for '${query}':\n\n` +
+                    results.map(r => `  ${r.symbol} (${r.kind}) — ${r.package}`).join('\n'),
+            }],
+    };
+}
+function findType(args, index) {
+    const pattern = (args.pattern || '').toLowerCase();
+    if (!pattern)
+        return { content: [{ type: 'text', text: 'pattern is required' }], isError: true };
+    const results = [];
+    for (const [pkgName, pkg] of Object.entries(index.packages)) {
+        for (const t of pkg.exports.interfaces) {
+            if (t.toLowerCase().includes(pattern))
+                results.push({ package: pkgName, type: t, kind: 'interface' });
+        }
+        for (const t of pkg.exports.types) {
+            if (t.toLowerCase().includes(pattern))
+                results.push({ package: pkgName, type: t, kind: 'type' });
+        }
+        for (const c of pkg.exports.classes) {
+            if (c.toLowerCase().includes(pattern))
+                results.push({ package: pkgName, type: c, kind: 'class' });
+        }
+    }
+    results.sort((a, b) => a.type.localeCompare(b.type));
+    if (results.length === 0) {
+        return { content: [{ type: 'text', text: `No types found matching '${pattern}'` }] };
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: `Found ${results.length} type(s) for '${pattern}':\n\n` +
+                    results.map(r => `  ${r.type} (${r.kind}) — ${r.package}`).join('\n'),
+            }],
+    };
+}
+function dependencyGraph(args, index) {
+    const pkgName = args.package;
+    const direction = args.direction || 'out';
+    if (!pkgName || !index.packages[pkgName]) {
+        return { content: [{ type: 'text', text: `Package '${pkgName}' not found` }], isError: true };
+    }
+    const pkg = index.packages[pkgName];
+    if (direction === 'out' || direction === 'all') {
+        const totemDeps = pkg.dependencies.filter(d => d.startsWith('@totemsdk/'));
+        const externalDeps = pkg.dependencies.filter(d => !d.startsWith('@totemsdk/'));
+        return {
+            content: [{
+                    type: 'text',
+                    text: `# ${pkgName} — Outbound Dependencies\n\n` +
+                        (totemDeps.length ? `**@totemsdk/* deps:**\n${totemDeps.map(d => `  - ${d}`).join('\n')}\n\n` : '') +
+                        (externalDeps.length ? `**External deps:**\n${externalDeps.map(d => `  - ${d}`).join('\n')}\n` : '_(no external deps)_'),
+                }],
+        };
+    }
+    if (direction === 'in' || direction === 'all') {
+        const dependents = [];
+        for (const [name, other] of Object.entries(index.packages)) {
+            if (other.dependencies.includes(pkgName))
+                dependents.push(name);
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: `# ${pkgName} — Inbound Dependents\n\n` +
+                        (dependents.length ? dependents.map(d => `  - ${d}`).join('\n') : '_(no dependents)_'),
+                }],
+        };
+    }
+    return { content: [{ type: 'text', text: 'Invalid direction. Use "in", "out", or "all".' }], isError: true };
+}
+function validateImport(args, index) {
+    const { from: fromPkg, to: toPkg, symbol } = args;
+    if (!fromPkg || !toPkg) {
+        return { content: [{ type: 'text', text: 'from and to package names are required' }], isError: true };
+    }
+    const fromPkgData = index.packages[fromPkg];
+    const toPkgData = index.packages[toPkg];
+    if (!fromPkgData)
+        return { content: [{ type: 'text', text: `Source package '${fromPkg}' not found` }], isError: true };
+    if (!toPkgData)
+        return { content: [{ type: 'text', text: `Target package '${toPkg}' not found` }], isError: true };
+    const hasDep = fromPkgData.dependencies.includes(toPkg);
+    const result = { valid: hasDep, importPath: toPkg, symbolFound: false };
+    if (hasDep) {
+        if (symbol) {
+            const allExports = [
+                ...toPkgData.exports.functions,
+                ...toPkgData.exports.types,
+                ...toPkgData.exports.classes,
+                ...toPkgData.exports.interfaces,
+                ...toPkgData.exports.consts,
+            ];
+            result.symbolFound = allExports.includes(symbol);
+            if (!result.symbolFound) {
+                result.valid = false;
+                result.reason = `'${toPkg}' does not export '${symbol}'`;
+            }
+        }
+    }
+    else {
+        result.reason = `'${fromPkg}' does not depend on '${toPkg}'`;
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(result, null, 2),
+            }],
+    };
+}
+function scaffoldAdapter(args) {
+    const { name, protocol, commands } = args;
+    if (!name || !protocol) {
+        return { content: [{ type: 'text', text: 'name and protocol are required' }], isError: true };
+    }
+    const cmdList = Array.isArray(commands) ? commands : ['connect', 'disconnect', 'read', 'write'];
+    const files = [];
+    files.push({
+        path: `src/index.ts`,
+        content: [
+            `export type { ${protocol}TransportPort } from './transport.js'`,
+            `export { create${protocol}Gateway } from './gateway.js'`,
+            `export type { ${protocol}GatewayConfig, ${protocol}Gateway } from './gateway.js'`,
+            `export { create${protocol}SensorBridge } from './sensor-bridge.js'`,
+            `export type { ${protocol}SensorBinding, ${protocol}SensorBridgeConfig } from './sensor-bridge.js'`,
+            ``,
+        ].join('\n'),
+    });
+    files.push({
+        path: `src/transport.ts`,
+        content: [
+            `export interface ${protocol}TransportPort {`,
+            ...cmdList.map(c => `  ${c}(...args: unknown[]): Promise<unknown>;`),
+            `  onError(handler: (err: Error) => void): () => void;`,
+            `}`,
+            ``,
+        ].join('\n'),
+    });
+    files.push({
+        path: `src/gateway.ts`,
+        content: [
+            `import type { ${protocol}TransportPort } from './transport.js'`,
+            `import type { EdgeRuntime } from '@totemsdk/edge'`,
+            ``,
+            `export interface ${protocol}GatewayConfig {`,
+            `  runtime: EdgeRuntime`,
+            `  transport: ${protocol}TransportPort`,
+            `}`,
+            ``,
+            `export interface ${protocol}Gateway {`,
+            `  start(): Promise<void>`,
+            `  stop(): Promise<void>`,
+            `}`,
+            ``,
+            `export function create${protocol}Gateway(config: ${protocol}GatewayConfig): ${protocol}Gateway {`,
+            `  return {`,
+            `    async start() { /* TODO: implement */ },`,
+            `    async stop() { /* TODO: implement */ },`,
+            `  }`,
+            `}`,
+            ``,
+        ].join('\n'),
+    });
+    files.push({
+        path: `src/sensor-bridge.ts`,
+        content: [
+            `import type { ${protocol}TransportPort } from './transport.js'`,
+            `import type { ${protocol}Gateway } from './gateway.js'`,
+            `import type { EdgeRuntime } from '@totemsdk/edge'`,
+            ``,
+            `export interface ${protocol}SensorBinding {`,
+            `  sensorId: string`,
+            `  intervalMs: number`,
+            `  dataType?: string`,
+            `  unit?: string`,
+            `}`,
+            ``,
+            `export interface ${protocol}SensorBridgeConfig {`,
+            `  runtime: EdgeRuntime`,
+            `  transport: ${protocol}TransportPort`,
+            `  gateway: ${protocol}Gateway`,
+            `  bindings: ${protocol}SensorBinding[]`,
+            `}`,
+            ``,
+            `export interface ${protocol}SensorBridge {`,
+            `  start(): Promise<void>`,
+            `  stop(): Promise<void>`,
+            `}`,
+            ``,
+            `export function create${protocol}SensorBridge(config: ${protocol}SensorBridgeConfig): ${protocol}SensorBridge {`,
+            `  return {`,
+            `    async start() { /* TODO: implement */ },`,
+            `    async stop() { /* TODO: implement */ },`,
+            `  }`,
+            `}`,
+            ``,
+        ].join('\n'),
+    });
+    return {
+        content: [{
+                type: 'text',
+                text: `# Scaffolded ${protocol} Edge Adapter\n\nCreated ${files.length} files:\n\n` +
+                    files.map(f => `**${f.path}**\n\`\`\`typescript\n${f.content}\n\`\`\``).join('\n\n'),
+            }],
+    };
+}
+function scaffoldPackage(args) {
+    const { name, deps } = args;
+    if (!name)
+        return { content: [{ type: 'text', text: 'name is required' }], isError: true };
+    const depList = Array.isArray(deps) ? deps : ['@totemsdk/core'];
+    const files = [];
+    files.push({
+        path: `package.json`,
+        content: JSON.stringify({
+            name: `@totemsdk/${name}`,
+            version: '0.1.0',
+            description: `TODO: describe ${name}`,
+            main: 'dist/index.js',
+            types: 'dist/index.d.ts',
+            exports: {
+                '.': {
+                    types: './dist/index.d.ts',
+                    require: './dist/index.js',
+                    import: './dist/index.js',
+                },
+            },
+            scripts: { build: 'tsc', clean: 'rm -rf dist', test: 'jest --passWithNoTests' },
+            files: ['dist', 'README.md', 'LICENSE'],
+            dependencies: Object.fromEntries(depList.map(d => [d, '^0.1.0'])),
+            devDependencies: {
+                '@types/jest': '^30.0.0',
+                '@types/node': '^20.0.0',
+                jest: '^30.4.2',
+                typescript: '^7.0.2',
+            },
+            publishConfig: { access: 'public' },
+            license: 'MIT',
+        }, null, 2),
+    });
+    files.push({
+        path: `tsconfig.json`,
+        content: JSON.stringify({
+            compilerOptions: {
+                target: 'ES2020',
+                module: 'commonjs',
+                declaration: true,
+                outDir: './dist',
+                rootDir: './src',
+                strict: true,
+                esModuleInterop: true,
+                skipLibCheck: true,
+                moduleResolution: 'bundler',
+                resolveJsonModule: true,
+            },
+            include: ['src/**/*'],
+            exclude: ['node_modules', 'dist', '**/*.test.ts'],
+        }, null, 2),
+    });
+    files.push({
+        path: `src/index.ts`,
+        content: [
+            `export {}`,
+            ``,
+        ].join('\n'),
+    });
+    files.push({
+        path: `src/types.ts`,
+        content: [
+            `export {}`,
+            ``,
+        ].join('\n'),
+    });
+    files.push({
+        path: `src/canonical.ts`,
+        content: [
+            `import { sha3_256 } from '@totemsdk/core'`,
+            ``,
+            `export function toHex(bytes: Uint8Array): string {`,
+            `  return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('')`,
+            `}`,
+            ``,
+            `export function canonicalJson(value: unknown): string {`,
+            `  if (value === null || typeof value !== 'object') return JSON.stringify(value)`,
+            `  if (Array.isArray(value)) return '[' + value.map(canonicalJson).join(',') + ']'`,
+            `  const obj = value as Record<string, unknown>`,
+            `  const keys = Object.keys(obj).sort()`,
+            `  const pairs = keys.map(k => JSON.stringify(k) + ':' + canonicalJson(obj[k]))`,
+            `  return '{' + pairs.join(',') + '}'`,
+            `}`,
+            ``,
+            `export function hashCanonical(domain: string, value: unknown): string {`,
+            `  return toHex(sha3_256(new TextEncoder().encode(domain + canonicalJson(value))))`,
+            `}`,
+            ``,
+        ].join('\n'),
+    });
+    return {
+        content: [{
+                type: 'text',
+                text: `# Scaffolded @totemsdk/${name}\n\nCreated ${files.length} files in ${name}/:\n\n` +
+                    files.map(f => `**${f.path}**\n\`\`\`\n${f.content}\n\`\`\``).join('\n\n'),
+            }],
+    };
+}
+function packageStats(args, index) {
+    const pkgName = args.name;
+    if (!pkgName || !index.packages[pkgName]) {
+        return { content: [{ type: 'text', text: `Package '${pkgName}' not found` }], isError: true };
+    }
+    const pkg = index.packages[pkgName];
+    const totalExports = pkg.exports.functions.length + pkg.exports.types.length +
+        pkg.exports.classes.length + pkg.exports.interfaces.length + pkg.exports.consts.length;
+    const totemDeps = pkg.dependencies.filter(d => d.startsWith('@totemsdk/'));
+    const externalDeps = pkg.dependencies.filter(d => !d.startsWith('@totemsdk/'));
+    return {
+        content: [{
+                type: 'text',
+                text: [
+                    `# ${pkgName} v${pkg.version}`,
+                    ``,
+                    `**Domain:** ${pkg.domain}`,
+                    `**Description:** ${pkg.description}`,
+                    `**Directory:** ${pkg.dir}`,
+                    ``,
+                    `| Metric | Value |`,
+                    `|--------|-------|`,
+                    `| Functions | ${pkg.exports.functions.length} |`,
+                    `| Types (named) | ${pkg.exports.types.length} |`,
+                    `| Interfaces | ${pkg.exports.interfaces.length} |`,
+                    `| Classes | ${pkg.exports.classes.length} |`,
+                    `| Constants | ${pkg.exports.consts.length} |`,
+                    `| **Total exports** | **${totalExports}** |`,
+                    `| Rust/WASM | ${pkg.hasRust ? 'Yes' : 'No'} |`,
+                    `| Go | ${pkg.hasGo ? 'Yes' : 'No'} |`,
+                    `| Tests | ${pkg.hasTests ? 'Yes' : 'No'} |`,
+                    `| @totemsdk/* deps | ${totemDeps.length} |`,
+                    `| External deps | ${externalDeps.length} |`,
+                    ``,
+                ].join('\n'),
+            }],
+    };
+}
+function listExports(args, index) {
+    const pkgName = args.package;
+    const kind = (args.kind || '').toLowerCase();
+    const filter = (args.filter || '').toLowerCase();
+    if (!pkgName || !index.packages[pkgName]) {
+        return { content: [{ type: 'text', text: `Package '${pkgName}' not found` }], isError: true };
+    }
+    const pkg = index.packages[pkgName];
+    const sections = [];
+    if (!kind || kind === 'function') {
+        const items = filter ? pkg.exports.functions.filter(s => s.toLowerCase().includes(filter)) : pkg.exports.functions;
+        if (items.length)
+            sections.push(`**Functions (${items.length}):**\n` + items.map(s => `  - \`${s}\``).join('\n'));
+    }
+    if (!kind || kind === 'interface') {
+        const items = filter ? pkg.exports.interfaces.filter(s => s.toLowerCase().includes(filter)) : pkg.exports.interfaces;
+        if (items.length)
+            sections.push(`**Interfaces (${items.length}):**\n` + items.map(s => `  - \`${s}\``).join('\n'));
+    }
+    if (!kind || kind === 'type') {
+        const items = filter ? pkg.exports.types.filter(s => s.toLowerCase().includes(filter)) : pkg.exports.types;
+        if (items.length)
+            sections.push(`**Named Types (${items.length}):**\n` + items.map(s => `  - \`${s}\``).join('\n'));
+    }
+    if (!kind || kind === 'class') {
+        const items = filter ? pkg.exports.classes.filter(s => s.toLowerCase().includes(filter)) : pkg.exports.classes;
+        if (items.length)
+            sections.push(`**Classes (${items.length}):**\n` + items.map(s => `  - \`${s}\``).join('\n'));
+    }
+    if (!kind || kind === 'const') {
+        const items = filter ? pkg.exports.consts.filter(s => s.toLowerCase().includes(filter)) : pkg.exports.consts;
+        if (items.length)
+            sections.push(`**Constants (${items.length}):**\n` + items.map(s => `  - \`${s}\``).join('\n'));
+    }
+    return {
+        content: [{ type: 'text', text: sections.join('\n\n') || `No exports found for '${pkgName}'` }],
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,56 @@
+export interface PackageIndex {
+    name: string;
+    dir: string;
+    version: string;
+    description: string;
+    dependencies: string[];
+    devDependencies: string[];
+    hasRust: boolean;
+    hasGo: boolean;
+    hasTests: boolean;
+    exports: PackageExports;
+    domain: string;
+}
+export interface PackageExports {
+    functions: string[];
+    types: string[];
+    classes: string[];
+    interfaces: string[];
+    consts: string[];
+}
+export interface SymbolEntry {
+    package: string;
+    kind: 'function' | 'type' | 'class' | 'interface' | 'const' | 'variable';
+}
+export interface DomainMap {
+    [domain: string]: string[];
+}
+export interface SdkIndex {
+    generatedAt: number;
+    packages: {
+        [name: string]: PackageIndex;
+    };
+    symbolIndex: {
+        [symbol: string]: SymbolEntry[];
+    };
+    domainMap: DomainMap;
+}
+export interface ToolResponse {
+    content: Array<{
+        type: string;
+        text: string;
+    }>;
+    isError?: boolean;
+}
+export interface ValidImportResult {
+    valid: boolean;
+    importPath?: string;
+    symbolFound?: boolean;
+    reason?: string;
+}
+export interface ScaffoldResult {
+    files: Array<{
+        path: string;
+        content: string;
+    }>;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@totemsdk/mcp-server",
+  "version": "0.1.0",
+  "description": "MCP server exposing the full Totem SDK package set — metadata, types, exports, dependency graphs, and scaffolding tools for 53 packages",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "totemsdk-mcp": "dist/index.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepare": "",
+    "clean": "rm -rf dist",
+    "start": "node dist/index.js"
+  },
+  "files": ["dist", "README.md", "LICENSE"],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^7.0.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "author": "Totem SDK",
+  "homepage": "https://totem.ing",
+  "bugs": {
+    "url": "https://github.com/totem-sdk/totem-sdk/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/totem-sdk/totem-sdk.git",
+    "directory": "packages/totem-sdk/packages/mcp-server"
+  },
+  "keywords": ["totem", "totemsdk", "mcp", "model-context-protocol", "sdk-index"]
+}