@totemsdk/mcp-server 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1 +1,12 @@
-export {};
+import type { SdkIndex } from './types.js';
+declare const index: SdkIndex;
+export declare const SERVER_INFO: {
+    readonly name: "@totemsdk/mcp-server";
+    readonly version: "0.2.0";
+    readonly capabilities: {
+        readonly resources: {};
+        readonly tools: {};
+        readonly prompts: {};
+    };
+};
+export { index as sdkIndex };

package/dist/index.js

@@ -1,5 +1,6 @@
 "use strict";
 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");
@@ -7,6 +8,7 @@ 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)();
+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),
@@ -111,6 +113,17 @@ server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
                 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'],
+            },
+        },
     ],
 }));
 server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
@@ -209,6 +222,11 @@ server.setRequestHandler(types_js_1.GetPromptRequestSchema, async (request) => {
     }
     throw new Error(`Prompt not found: ${name}`);
 });
+exports.SERVER_INFO = {
+    name: '@totemsdk/mcp-server',
+    version: '0.2.0',
+    capabilities: { resources: {}, tools: {}, prompts: {} },
+};
 async function main() {
     const transport = new stdio_js_1.StdioServerTransport();
     await server.connect(transport);

package/dist/indexer.js

@@ -37,7 +37,16 @@ exports.buildIndex = buildIndex;
 exports.readSourceFile = readSourceFile;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const REPO_ROOT = path.resolve(__dirname, '..', '..', '..', '..', '..', '..');
+function findRepoRoot() {
+    let dir = path.resolve(__dirname);
+    while (dir !== path.dirname(dir)) {
+        if (fs.existsSync(path.join(dir, 'pnpm-workspace.yaml')))
+            return dir;
+        dir = path.dirname(dir);
+    }
+    return dir;
+}
+const REPO_ROOT = findRepoRoot();
 const PKG_DIR = path.join(REPO_ROOT, 'packages', 'totem-sdk', 'packages');
 const TOP_PKG_DIR = path.join(REPO_ROOT, 'packages');
 const DOMAIN_GROUPS = [
@@ -45,11 +54,11 @@ const DOMAIN_GROUPS = [
     [/^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'],
+    [/^edge-(bacnet|ble|can|coap|email|grpc|lorawan|matter|modbus|mqtt|opcua|ros2)$/, 'edge/protocols'],
+    [/^omnia(-factory|-router|-splice|-vtxo|-host)?$/, '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'],
+    [/^stream-transport$|^pubsub-transport$|^minima-rpc$|^server$|^se-server$|^realtime$|^connect$|^wallet-adapter$|^pear$|^mcp-server$|^observability$/, 'utilities'],
     [/^sdk-tests$/, 'testing'],
 ];
 function classifyDomain(dirName) {
@@ -109,11 +118,13 @@ function parseExports(dir, pkgName) {
     if (!content)
         return exports;
     const lines = content.split('\n');
-    for (const line of lines) {
-        const trimmed = line.trim();
+    let i = 0;
+    while (i < lines.length) {
+        const trimmed = lines[i].trim();
         const fnMatch = trimmed.match(/^export (async )?function (\w+)/);
         if (fnMatch) {
             exports.functions.push(fnMatch[2]);
+            i++;
             continue;
         }
         const typeMatch = trimmed.match(/^export type \{ ([^}]+) \}/);
@@ -123,37 +134,58 @@ function parseExports(dir, pkgName) {
                 if (name)
                     exports.types.push(name);
             });
+            i++;
             continue;
         }
         const clsMatch = trimmed.match(/^export class (\w+)/);
         if (clsMatch) {
             exports.classes.push(clsMatch[1]);
+            i++;
             continue;
         }
         const ifaceMatch = trimmed.match(/^export interface (\w+)/);
         if (ifaceMatch) {
             exports.interfaces.push(ifaceMatch[1]);
+            i++;
             continue;
         }
         const constMatch = trimmed.match(/^export (const|let|var) (\w+)/);
         if (constMatch) {
             exports.consts.push(constMatch[2]);
+            i++;
             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('}'))
+        // Handle multi-line export { ... } from '...' blocks
+        if (trimmed.startsWith('export {') || trimmed.startsWith('export type {')) {
+            const isType = trimmed.startsWith('export type {');
+            let block = trimmed;
+            let j = i;
+            while (!block.includes('}') && j < lines.length - 1) {
+                j++;
+                block += ' ' + lines[j].trim();
+            }
+            // Extract name list between { and }
+            const braceMatch = block.match(/\{([^}]+)\}/);
+            if (braceMatch) {
+                for (const part of braceMatch[1].split(',')) {
+                    const name = part.trim().split(/\s+as\s+/).pop()?.trim() || '';
+                    if (!name || name.endsWith('}'))
                         continue;
-                    if (/^[A-Z]/.test(name))
+                    if (isType) {
                         exports.types.push(name);
-                    else
-                        exports.functions.push(name);
+                    }
+                    else {
+                        if (/^[A-Z]/.test(name))
+                            exports.types.push(name);
+                        else
+                            exports.functions.push(name);
+                    }
                 }
             }
+            i = j + 1;
+            continue;
         }
+        i++;
     }
     return exports;
 }

package/dist/resources.js

@@ -1,7 +1,91 @@
 "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.handleResourceRead = handleResourceRead;
 exports.listResources = listResources;
+const template_catalog_js_1 = require("./template-catalog.js");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function findRepoRoot() {
+    let dir = path.resolve(__dirname);
+    while (dir !== path.dirname(dir)) {
+        if (fs.existsSync(path.join(dir, 'pnpm-workspace.yaml')))
+            return dir;
+        dir = path.dirname(dir);
+    }
+    return dir;
+}
+const REPO_ROOT = findRepoRoot();
+const PAPERS = [
+    {
+        uri: 'totemsdk://papers/yellow',
+        name: 'Core Yellow Paper',
+        description: 'WOTS+ signatures, TreeKey hierarchy, MMR proofs, byte-exact serialization, lease/watermark coordination, Rust/WASM engine',
+        file: 'TOTEM_CORE_YELLOW_PAPER.md',
+    },
+    {
+        uri: 'totemsdk://papers/red',
+        name: 'Connect Red Paper',
+        description: 'dApp-wallet wire protocol specification — all 49 methods, every parameter, every response shape, error codes, security model',
+        file: 'TOTEM_CONNECT_RED_PAPER.md',
+    },
+    {
+        uri: 'totemsdk://papers/blue',
+        name: 'Omnia Blue Paper',
+        description: 'P2P payment channels, eltoo state machine, multi-hop routing, channel factories, VTXO accounting, statechain prepaid passes, lending/borrowing, off-chain tokens, privacy by design, scaling to billions of devices',
+        file: 'TOTEM_OMNIA_BLUE_PAPER.md',
+    },
+    {
+        uri: 'totemsdk://papers/green',
+        name: 'Governance Green Paper',
+        description: 'Authority mandates, delegation chains, recursive MAST 7-layer policy trees, quadratic voting, liquid democracy, QVAC agent policy, modular governance patterns',
+        file: 'TOTEM_GOVERNANCE_GREEN_PAPER.md',
+    },
+    {
+        uri: 'totemsdk://papers/grey',
+        name: 'Edge Grey Paper',
+        description: 'Port-injected transport-agnostic edge runtime, 11 protocol adapters, MachinePay credit gating, offline operation, industrial action, sensor-to-settlement bridge',
+        file: 'TOTEM_EDGE_GREY_PAPER.md',
+    },
+    {
+        uri: 'totemsdk://papers/gold',
+        name: 'Tokenomics Gold Paper',
+        description: 'Two-asset model — MINIMA as sovereign collateral backbone (Colour Coins, The Burn, Provider Bonds), TOTEM as service revenue token (staking, fee distribution, slashing, treasury)',
+        file: 'TOTEM_TOKENOMICS_GOLD_PAPER.md',
+    },
+];
 const CONVENTIONS = `# Totem SDK Conventions
 
 ## Package Structure
@@ -46,6 +130,18 @@ const CONVENTIONS = `# Totem SDK Conventions
 - Promise<T> everywhere, typed event emitters, no Observables
 - Action lifecycle: propose -> reserve -> execute -> confirm/fail/unknown`;
 function handleResourceRead(uri, index) {
+    const paperMatch = uri.match(/^totemsdk:\/\/papers\/(\w+)$/);
+    if (paperMatch) {
+        const paper = PAPERS.find(p => p.uri === uri);
+        if (paper) {
+            const filePath = path.join(REPO_ROOT, paper.file);
+            if (fs.existsSync(filePath)) {
+                return fs.readFileSync(filePath, 'utf-8');
+            }
+            return `Paper file not found: ${paper.file}`;
+        }
+        return null;
+    }
     if (uri === 'totemsdk://packages') {
         return JSON.stringify(Object.values(index.packages).map(p => ({
             name: p.name,
@@ -59,6 +155,19 @@ function handleResourceRead(uri, index) {
     }
     if (uri === 'totemsdk://conventions')
         return CONVENTIONS;
+    if (uri === 'totemsdk://templates') {
+        const all = (0, template_catalog_js_1.getAllTemplates)();
+        return all.map(t => {
+            const pkgs = Array.isArray(t.package) ? t.package : t.package ? [t.package] : [];
+            return {
+                template: t.template,
+                functions: t.functions,
+                configTypes: t.configTypes,
+                package: pkgs.length > 0 ? pkgs.map(p => `@totemsdk/${p}`) : ['@totemsdk/kissvm'],
+                description: t.description,
+            };
+        }).map(t => `## ${t.template}\n\n${t.description}\n\n**Package:** ${t.package.join(', ')}\n\n**Functions:**\n${t.functions.map(f => `  - \`import { ${f} } from '@totemsdk/kissvm'\``).join('\n')}\n`).join('\n---\n');
+    }
     if (uri === 'totemsdk://domain-map') {
         return JSON.stringify(index.domainMap, null, 2);
     }
@@ -93,9 +202,11 @@ function handleResourceRead(uri, index) {
 }
 function listResources(index) {
     const resources = [
-        { uri: 'totemsdk://packages', name: 'All Packages', description: 'List of all 53 SDK packages with metadata' },
+        { uri: 'totemsdk://packages', name: 'All Packages', description: `List of all ${Object.keys(index.packages).length} SDK packages with metadata` },
+        { uri: 'totemsdk://templates', name: 'All KISSVM Templates', description: 'All 45 KISSVM script templates with import paths and descriptions' },
         { 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' },
+        ...PAPERS.map(p => ({ uri: p.uri, name: p.name, description: p.description })),
     ];
     for (const [domain, pkgs] of Object.entries(index.domainMap)) {
         resources.push({

package/dist/template-catalog.d.ts

@@ -0,0 +1,12 @@
+export interface TemplateEntry {
+    template: string;
+    functions: string[];
+    configTypes: string[];
+    package: string | string[] | null;
+    keywords: string[];
+    description: string;
+}
+export declare const TEMPLATE_CATALOG: TemplateEntry[];
+export declare function getTemplatesForPackage(pkgName: string): TemplateEntry[];
+export declare function searchTemplates(query: string): TemplateEntry[];
+export declare function getAllTemplates(): TemplateEntry[];

package/dist/template-catalog.js

@@ -0,0 +1,406 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEMPLATE_CATALOG = void 0;
+exports.getTemplatesForPackage = getTemplatesForPackage;
+exports.searchTemplates = searchTemplates;
+exports.getAllTemplates = getAllTemplates;
+exports.TEMPLATE_CATALOG = [
+    {
+        template: 'authority',
+        functions: ['buildMandateEnforcementScript', 'buildActionAuthorizationScript', 'buildAuthorityRevocationScript', 'buildUsageTrackingScript'],
+        configTypes: ['MandateEnforcementConfig', 'ActionAuthorizationConfig', 'AuthorityRevocationConfig', 'UsageTrackingConfig'],
+        package: 'authority',
+        keywords: ['mandate', 'authorization', 'replay protection', 'nonce', 'usage tracking', 'revocation epoch', 'scope', 'action auth', 'governance authority'],
+        description: 'Mandate enforcement, action authorization with nonce replay protection, usage tracking against limits, and revocation epoch scripts',
+    },
+    {
+        template: 'agent-policy',
+        functions: ['buildPaymentIntentScript', 'buildAgentProposalScript', 'buildPolicyEnforcementScript'],
+        configTypes: ['PaymentIntentConfig', 'AgentProposalConfig', 'PolicyEnforcementConfig'],
+        package: 'agent-policy',
+        keywords: ['payment intent', 'agent proposal', 'policy enforcement', 'risk threshold', 'confidence', 'status transition', 'autonomous agent', 'policy rules'],
+        description: 'Autonomous agent payment intents, proposal state machines with confidence thresholds, and policy rule enforcement',
+    },
+    {
+        template: 'eltoo',
+        functions: ['buildEltooChannelScript', 'buildEltooFundingScript', 'buildEltooSettlementScript', 'buildFactoryFundingScript'],
+        configTypes: ['EltooConfig', 'FactoryConfig'],
+        package: ['omnia', 'omnia-factory'],
+        keywords: ['eltoo', 'ln symmetry', 'channel', 'payment channel', 'funding', 'settlement', 'sequence', 'coinage', 'multisig', 'n-of-n', 'factory', 'channel factory'],
+        description: 'Eltoo/LN-Symmetry channel scripts with settlement/update paths, channel funding scripts, and N-of-N factory funding scripts',
+    },
+    {
+        template: 'governance',
+        functions: ['buildProposalStateMachineScript', 'buildVoteSubmissionScript', 'buildVoteTallyScript', 'buildExecutionMandateScript', 'buildTreasuryExecutionScript', 'computeScriptHash'],
+        configTypes: ['ProposalConfig', 'VoteSubmissionConfig', 'VoteTallyConfig', 'ExecutionMandateConfig', 'TreasuryExecutionConfig'],
+        package: 'governance',
+        keywords: ['proposal', 'state machine', 'vote submit', 'vote tally', 'quorum', 'execution mandate', 'treasury', 'execution delay', 'multisig', 'governance', 'dao', 'voting', 'commitments'],
+        description: 'Proposal lifecycle 7-status state machine, vote submission with nonce/weight/window, on-chain vote tally with batch delta ports, execution mandate with timelock+multisig+commitments, and treasury fund release',
+    },
+    {
+        template: 'industrial-action',
+        functions: ['buildCommitScript', 'buildRevealScript', 'buildActionStateMachineScript', 'buildEscrowEnforcementScript'],
+        configTypes: ['CommitConfig', 'RevealConfig', 'ActionStateMachineConfig', 'EscrowEnforcementConfig'],
+        package: 'industrial-action',
+        keywords: ['industrial action', 'strike', 'commit reveal', 'hash commit', 'preimage reveal', 'state machine', 'notice period', 'max duration', 'escrow', 'condition enforcement'],
+        description: 'Industrial action scripts: hash-commit and preimage reveal, 6-status action FSM (proposed/noticed/active/resolved/escalated/expired) with notice period and max duration, and condition-based escrow enforcement',
+    },
+    {
+        template: 'identity',
+        functions: ['buildIdentityVerificationScript', 'buildDelegationProofScript', 'buildRotationScript', 'buildRevocationScript'],
+        configTypes: ['IdentityVerificationConfig', 'DelegationProofConfig', 'RotationConfig', 'RevocationConfig'],
+        package: 'identity',
+        keywords: ['identity', 'verification', 'delegation', 'proof', 'key rotation', 'revocation', 'claim', 'did', 'public key'],
+        description: 'Identity verification with claim hashing, delegation proofs with expiry, key rotation with delay, and revocation with epoch',
+    },
+    {
+        template: 'liquidity-bond',
+        functions: ['buildLiquidityLockScript', 'buildFeeAccrualScript', 'buildWithdrawalScript', 'buildPositionStateMachineScript'],
+        configTypes: ['LiquidityLockConfig', 'PositionStateMachineConfig'],
+        package: 'liquidity-bond',
+        keywords: ['liquidity', 'bond', 'lock', 'unlock after block', 'cliff', 'fee accrual', 'pro rata', 'withdrawal', 'position', 'vesting', 'state machine'],
+        description: 'Liquidity lock terms with status-gated cliffs, time-pro-rated fee accrual with VERIFYOUT to governance, bounded withdrawal count, and 5-active-status position FSM',
+    },
+    {
+        template: 'lookup-protocol',
+        functions: ['buildLeaseMessageScript', 'buildCoinUpdateScript', 'buildTrustMessageScript'],
+        configTypes: ['LeaseMessageConfig', 'CoinUpdateConfig', 'TrustMessageConfig'],
+        package: 'lookup-protocol',
+        keywords: ['lease message', 'coin update', 'trust message', 'event type', 'new spent confirmed', 'expiry', 'state machine', 'lookup', 'p2p'],
+        description: 'Lease message validation with temporal deadline, coin update event type state machine, and trust message validation with expiry window',
+    },
+    {
+        template: 'manifest',
+        functions: ['buildManifestBindingScript', 'buildCapabilityScript', 'buildManifestExpiryScript'],
+        configTypes: ['ManifestBindingConfig', 'CapabilityConfig', 'ManifestExpiryConfig'],
+        package: 'manifest',
+        keywords: ['manifest', 'binding', 'capability', 'permission', 'expiry', 'subscription interval', 'signed at', 'publisher', 'app manifest'],
+        description: 'Manifest-to-identity binding with SHA3 hash, capability permission enforcement, and manifest expiry with subscription interval rate-limit',
+    },
+    {
+        template: 'proof',
+        functions: ['buildProofAnchorScript', 'buildCapabilityProofScript', 'buildRevocationProofScript', 'buildProofDelegationScript'],
+        configTypes: ['ProofConfig'],
+        package: 'proof',
+        keywords: ['proof', 'anchor', 'capability', 'revocation', 'delegation', 'confirm at', 'expires at', 'proof chain'],
+        description: 'Proof anchoring with confirmed-at block, capability/revocation/delegation proof scripts with temporal expiry',
+    },
+    {
+        template: 'provider-bond',
+        functions: ['buildBondLockupScript', 'buildHeartbeatScript', 'buildBondStateMachineScript', 'buildChallengeScript', 'buildBondReleaseScript'],
+        configTypes: ['ProviderBondConfig', 'BondStateMachineConfig', 'ChallengeConfig'],
+        package: 'provider-bond',
+        keywords: ['provider bond', 'stake', 'lockup', 'heartbeat', 'sla', 'bond release', 'unbonding', 'slashing', 'challenge deadline', 'state machine', 'challenge commit', 'file uphold dismiss'],
+        description: 'Provider bond lockup with status-gated cliffs, heartbeat enforcement with PREVSTATE elapsed tracking, 7-status bond FSM, commit/file/uphold/dismiss challenge cycle with VERIFYOUT, and bond release with governance override',
+    },
+    {
+        template: 'statechain',
+        functions: ['buildStatechainScript', 'buildStatechainOwnerRotationScript'],
+        configTypes: ['StateChainConfig'],
+        package: 'statechain',
+        keywords: ['statechain', 'owner rotation', 'state utxo', 'coinage reclaim', 'owner transfer', 'multisig state'],
+        description: 'Statechain UTXO locking script with owner rotation via STATE(0), MULTISIG(2) path, and coinage-based unilateral reclaim',
+    },
+    {
+        template: 'temporal',
+        functions: ['buildLinearRelease', 'buildCliffRelease', 'buildDeadlineScript', 'buildWindowScript', 'buildRateLimitScript', 'buildDecayScript', 'buildTemporalScript', 'computeRelease'],
+        configTypes: ['TemporalConfig'],
+        package: null,
+        keywords: ['temporal', 'linear release', 'vesting', 'cliff', 'deadline', 'window', 'rate limit', 'decay', 'hyperbolic', 'time lock', 'block arithmetic', 'release curve'],
+        description: 'Six temporal release curves: linear (vestr), cliff (delayed start), deadline (must claim before), window (valid between blocks), rate-limit (max per period), decay (hyperbolic). Includes off-chain computeRelease mirror',
+    },
+    {
+        template: 'txpow',
+        functions: ['buildTxPoWValidationScript', 'buildMagicConstantsScript'],
+        configTypes: ['TxPoWValidationConfig'],
+        package: 'txpow',
+        keywords: ['txpow', 'transaction validation', 'magic constants', 'max size', 'max ops', 'min work', 'protocol constants'],
+        description: 'TxPoW validation scripts for max transaction size, max KISSVM ops, minimum work threshold, and magic protocol constant enforcement',
+    },
+    {
+        template: 'wots-lease',
+        functions: ['buildLeaseCertificateScript', 'buildWatermarkTrackingScript', 'buildLeaseStateMachineScript'],
+        configTypes: ['LeaseCertificateConfig'],
+        package: 'wots-lease',
+        keywords: ['wots', 'lease', 'certificate', 'watermark', 'key lease', 'state machine', 'pending active expired', 'tree id', 'device id'],
+        description: 'WOTS lease certificate validation with temporal expiry, monotonically advancing watermark tracking, and lease state machine with pending/active/expired transitions',
+    },
+    {
+        template: 'commercial',
+        functions: ['maasLayer', 'payPerUseLayer', 'featureLicenseLayer', 'warrantyLayer', 'escrowLayer', 'leasingLayer', 'telemetryLicenseLayer', 'carbonProgrammeLayer', 'usageBasedInsuranceLayer', 'vehicleToGridLayer'],
+        configTypes: [],
+        package: null,
+        keywords: ['commercial', 'maas', 'pay per use', 'feature license', 'warranty', 'escrow', 'leasing', 'telemetry', 'carbon', 'insurance', 'v2g', 'monetization'],
+        description: 'Commercial MAST policy layers for MaaS, pay-per-use, feature licensing, warranty, escrow, leasing, telemetry, carbon programmes, usage-based insurance, and vehicle-to-grid',
+    },
+    {
+        template: 'compliance',
+        functions: ['buildCompliancePipeline', 'buildStandardCompliancePipeline', 'buildSupplyChainPipeline'],
+        configTypes: ['ComplianceStage', 'CompliancePipelineConfig'],
+        package: null,
+        keywords: ['compliance', 'pipeline', 'kyc', 'aml', 'sanctions', 'regulatory', 'supply chain compliance', 'audit'],
+        description: 'Compliance pipeline builder for regulatory stages, KYC/AML checks, and supply chain compliance verification',
+    },
+    {
+        template: 'data-privacy',
+        functions: ['buildDataAccessConsentScript', 'buildGdprSubjectRequestScript', 'buildDataPortabilityScript', 'buildZkProofIntegrationScript', 'buildDataEscrowScript'],
+        configTypes: [],
+        package: null,
+        keywords: ['data privacy', 'gdpr', 'consent', 'subject request', 'data portability', 'zk proof', 'escrow', 'personal data'],
+        description: 'Data privacy scripts for GDPR consent management, subject access requests, data portability, zero-knowledge proof integration, and data escrow',
+    },
+    {
+        template: 'device-lifecycle',
+        functions: ['commissioningLayer', 'transferLayer', 'keyRotationLayer', 'recoveryLayer', 'decommissioningLayer', 'remoteSupportLayer', 'configurationProfileLayer', 'certificateIssuanceLayer'],
+        configTypes: [],
+        package: null,
+        keywords: ['device lifecycle', 'commissioning', 'transfer', 'key rotation', 'recovery', 'decommissioning', 'remote support', 'config profile', 'certificate'],
+        description: 'Device lifecycle MAST policy layers for commissioning, ownership transfer, key rotation, recovery, decommissioning, remote support, configuration profiles, and certificate issuance',
+    },
+    {
+        template: 'energy',
+        functions: ['buildRecTradingScript', 'buildMicrogridScript', 'buildP2PEnergyScript', 'buildDemandResponseScript', 'buildNetMeteringScript'],
+        configTypes: [],
+        package: null,
+        keywords: ['energy', 'rec', 'renewable energy certificate', 'microgrid', 'p2p energy', 'demand response', 'net metering', 'smart grid'],
+        description: 'Energy trading scripts for REC trading, microgrid management, peer-to-peer energy, demand response, and net metering',
+    },
+    {
+        template: 'firmware-update',
+        functions: ['buildFirmwareUpdateScript'],
+        configTypes: ['FirmwareUpdateConfig'],
+        package: null,
+        keywords: ['firmware update', 'ota', 'over the air', 'signed update', 'version verification'],
+        description: 'Secure firmware update script with signed update verification and version enforcement',
+    },
+    {
+        template: 'healthcare',
+        functions: ['buildMedicalDeviceRegulationScript', 'buildPatientConsentScript', 'buildClinicalTrialScript', 'buildPrescriptionScript', 'buildHealthDataAccessScript'],
+        configTypes: [],
+        package: null,
+        keywords: ['healthcare', 'medical device', 'regulation', 'patient consent', 'clinical trial', 'prescription', 'health data', 'hipaa'],
+        description: 'Healthcare scripts for medical device regulation compliance, patient consent management, clinical trial data, prescription verification, and health data access',
+    },
+    {
+        template: 'layers',
+        functions: ['assetLayer', 'manufacturerLayer', 'productLayer', 'regulatoryLayer', 'ownerLayer', 'siteLayer', 'operatorLayer', 'emergencyLayer'],
+        configTypes: [],
+        package: null,
+        keywords: ['mast layer', 'policy layer', 'asset', 'manufacturer', 'product', 'regulatory', 'owner', 'site', 'operator', 'emergency', 'layered policy'],
+        description: 'Standard 7-layer MAST policy chain: asset → manufacturer → product → regulatory → owner → site → operator, plus emergency override layer',
+    },
+    {
+        template: 'legal',
+        functions: ['buildDocumentNotarizationScript', 'buildTimestampVerificationScript', 'buildSmartContractExecutionScript', 'buildPowerOfAttorneyScript', 'buildMultiJurisdictionScript'],
+        configTypes: [],
+        package: null,
+        keywords: ['legal', 'notarization', 'timestamp', 'smart contract', 'power of attorney', 'multi jurisdiction', 'document'],
+        description: 'Legal scripts for document notarization, timestamp verification, smart contract execution, power of attorney, and multi-jurisdiction enforcement',
+    },
+    {
+        template: 'payment-channel',
+        functions: ['buildPaymentChannelScript', 'buildChannelFactoryScript'],
+        configTypes: ['PaymentChannelConfig'],
+        package: null,
+        keywords: ['payment channel', 'channel factory', 'micro payment', 'state channel', 'off chain', 'layer 2'],
+        description: 'Payment channel script with MAST-based state updates and channel factory for N-of-N funding with settlement paths',
+    },
+    {
+        template: 'recovery',
+        functions: ['buildThresholdRecoveryScript', 'buildEpochRotationScript', 'buildDelegatedCredentialScript', 'buildInstitutionalHierarchy', 'buildSuccessionScript'],
+        configTypes: ['ThresholdRecoveryConfig', 'EpochRotationConfig', 'DelegatedCredentialConfig', 'InstitutionalHierarchyConfig', 'SuccessionConfig'],
+        package: null,
+        keywords: ['recovery', 'threshold', 'social recovery', 'epoch rotation', 'delegated credential', 'institutional hierarchy', 'succession', 'key recovery'],
+        description: 'Key recovery scripts: threshold/social recovery, epoch-based key rotation, delegated credentials, institutional hierarchy, and succession planning',
+    },
+    {
+        template: 'rwa-lifecycle',
+        functions: ['buildAssetTokenizationScript', 'buildFractionalizationScript', 'buildAuditTrailScript', 'buildDistributionScript', 'buildShareTransferScript', 'buildRedemptionScript', 'buildAssetDisposalScript', 'buildRwaPolicyTree'],
+        configTypes: [],
+        package: null,
+        keywords: ['rwa', 'real world asset', 'tokenization', 'fractionalization', 'audit trail', 'distribution', 'share transfer', 'redemption', 'disposal'],
+        description: 'Real-world asset lifecycle scripts for tokenization, fractionalization, audit trails, distribution, share transfer, redemption, and asset disposal',
+    },
+    {
+        template: 'sensor-proof',
+        functions: ['buildSensorProofScript', 'buildSensorFleetPolicy', 'buildSensorProofChain'],
+        configTypes: ['SensorProofConfig'],
+        package: null,
+        keywords: ['sensor', 'proof', 'iot', 'data proof', 'sensor fleet', 'proof chain', 'telemetry'],
+        description: 'Sensor data proof scripts for individual sensor attestations, fleet-wide policies, and chained multi-sensor proofs',
+    },
+    {
+        template: 'state-machine',
+        functions: ['buildStateMachineScript', 'buildStateMachineWorkflow', 'onOffStateMachine', 'hvacStateMachine', 'productionStateMachine', 'robotArmStateMachine'],
+        configTypes: ['StateMachineConfig'],
+        package: null,
+        keywords: ['state machine', 'workflow', 'on off', 'hvac', 'production', 'robot arm', 'iot state', 'device state'],
+        description: 'Generic state machine template with predefined workflows for on/off devices, HVAC systems, production lines, and robot arms',
+    },
+    {
+        template: 'supply-chain',
+        functions: ['buildProvenanceScript', 'buildColdChainScript', 'buildBillOfLadingScript', 'buildCustomsClearanceScript', 'buildInventoryScript', 'buildQualityInspectionScript'],
+        configTypes: [],
+        package: null,
+        keywords: ['supply chain', 'provenance', 'cold chain', 'bill of lading', 'customs clearance', 'inventory', 'quality inspection', 'logistics'],
+        description: 'Supply chain scripts for provenance tracking, cold chain monitoring, bills of lading, customs clearance, inventory management, and quality inspection',
+    },
+    {
+        template: 'treasury',
+        functions: ['buildMultiSigTreasuryScript', 'buildBudgetAllocationScript', 'buildTimeLockedReserveScript', 'buildProposalExecutionScript', 'buildStreamingPaymentScript', 'buildTreasuryDelegationChain'],
+        configTypes: [],
+        package: null,
+        keywords: ['treasury', 'multisig', 'budget', 'time lock', 'reserve', 'proposal execution', 'streaming payment', 'delegation chain', 'fund management'],
+        description: 'Treasury management scripts for multi-sig control, budget allocation, time-locked reserves, proposal execution, streaming payments, and delegation chains',
+    },
+    {
+        template: 'voting',
+        functions: ['buildWeightedVotingScript', 'buildLiquidDemocracyScript', 'buildQuadraticVotingScript', 'buildElectionVerificationScript', 'buildDelegateRecallScript'],
+        configTypes: [],
+        package: null,
+        keywords: ['voting', 'weighted', 'liquid democracy', 'quadratic', 'election', 'delegate recall', 'governance vote', 'ballot'],
+        description: 'Voting scripts for weighted voting, liquid democracy delegation, quadratic voting, election verification, and delegate recall',
+    },
+    {
+        template: 'recursive-mast-delegation',
+        functions: ['buildDelegationLink', 'buildDelegationScript', 'buildDelegationChain', 'verifyDelegationChain', 'toDelegationChainScript'],
+        configTypes: [],
+        package: 'recursive-mast',
+        keywords: ['delegation chain', 'delegation link', 'authority delegation', 'nested mast delegation', 'policy delegation', 'recursive mast'],
+        description: 'Recursive MAST delegation chain builder — hierarchical authority delegation with proof-of-delegation via nested MAST. Builds on top of KISSVM policy-tree and proof-chain primitives',
+    },
+    {
+        template: 'recursive-mast-cross-domain',
+        functions: ['buildCrossDomainBridge', 'buildAcceptanceScript', 'buildBidirectionalBridge', 'buildTrustNetwork'],
+        configTypes: [],
+        package: 'recursive-mast',
+        keywords: ['cross domain', 'trust bridge', 'inter policy', 'acceptance script', 'bidirectional bridge', 'trust network', 'domain trust'],
+        description: 'Cross-domain trust bridge for inter-policy-space trust — enables policies in different domains to recognise and verify each other through acceptance scripts and bidirectional bridges',
+    },
+    {
+        template: 'recursive-mast-migration',
+        functions: ['buildMigrationStep', 'buildMigrationScript', 'buildMigrationPath', 'isMigrationActive', 'isMigrationComplete', 'getActivePolicyRoot', 'toMigrationPathScript'],
+        configTypes: [],
+        package: 'recursive-mast',
+        keywords: ['migration path', 'policy migration', 'upgradeable policy', 'migration step', 'policy root rotation', 'version upgrade'],
+        description: 'Policy migration path constructor — upgradeable policy systems with step-by-step migration scripts, active root tracking, and version transitions via the policy anchor coin',
+    },
+    {
+        template: 'recursive-mast-signing',
+        functions: ['createSigningRequest', 'createSigningResponse', 'collectSigningResponses', 'buildRecursiveWitnessPlan', 'verifySigningRequest'],
+        configTypes: ['CreateSigningRequestConfig', 'CreateSigningResponseConfig', 'SigningRoundResult', 'PolicySigningRequest', 'PolicySigningResponse', 'ScriptDisclosure', 'SignedEvidence', 'PolicyPathDescriptor'],
+        package: 'recursive-mast',
+        keywords: ['signing request', 'signing response', 'witness plan', 'multi party signing', 'transaction signing', 'policy signing', 'collect signatures'],
+        description: 'Policy signing request/response coordination — multi-party signing with recursive witness planning, script disclosure, and signed evidence collection for nested MAST transactions',
+    },
+    {
+        template: 'recursive-mast-session',
+        functions: ['createSigningSession', 'advanceSession', 'acceptResponse', 'recordEvidence', 'submitSession', 'confirmSession', 'cancelSession', 'sessionSummary'],
+        configTypes: ['SigningSession', 'SigningSessionConfig', 'SigningSessionStatus', 'RequiredRoleState', 'EvidenceState'],
+        package: 'recursive-mast',
+        keywords: ['signing session', 'multi party', 'state machine', 'evidence collection', 'transaction coordination', 'signing round', 'session management'],
+        description: 'Multi-party signing session state machine — manages the full lifecycle of a coordinated signing round: create, advance through required roles, accept responses, record evidence, submit, confirm, or cancel',
+    },
+    {
+        template: 'recursive-mast-discovery',
+        functions: ['announcePolicy', 'queryPolicies', 'resolvePolicyForSubject', 'watchPolicy'],
+        configTypes: ['PolicyLookupClient', 'PolicyQueryResult', 'PolicyUpdateNotification', 'AnnouncePolicyConfig', 'QueryPolicyConfig', 'ResolvePolicyConfig', 'ResolvedPolicy', 'WatchPolicyConfig'],
+        package: 'recursive-mast',
+        keywords: ['policy discovery', 'announce', 'query', 'resolve', 'watch', 'policy lookup', 'service discovery', 'policy registry'],
+        description: 'Policy discovery protocol — announce policies to a lookup client, query available policies, resolve policies for specific subjects, and watch for updates',
+    },
+    {
+        template: 'recursive-mast-branch-capsule',
+        functions: ['serializeBranchPackage', 'deserializeBranchPackage', 'verifyBranchPackage', 'createBranchPackage', 'branchSummary'],
+        configTypes: ['MastBranchPackage', 'BranchFilter', 'MastBranchSummary'],
+        package: 'recursive-mast',
+        keywords: ['branch capsule', 'branch package', 'serialize', 'deserialize', 'verify branch', 'self contained', 'script proof package'],
+        description: 'Branch capsule — self-contained MAST script+proof packages that can be serialised, verified, and transferred as a unit',
+    },
+    {
+        template: 'recursive-mast-policy-manifest',
+        functions: ['computePolicyPackageHash', 'signPolicyManifest', 'splitPolicyManifest'],
+        configTypes: ['RecursiveMastPolicyManifest', 'PolicyAction', 'PolicyRole', 'PolicyEndpoint', 'RestrictedBranchPackage'],
+        package: 'recursive-mast',
+        keywords: ['policy manifest', 'policy metadata', 'signed policy', 'policy hash', 'policy split', 'discoverable policy'],
+        description: 'Policy manifest — signed, discoverable policy metadata with package hashing, signing, and splitting for nested MAST governance structures',
+    },
+    {
+        template: 'recursive-mast-store',
+        functions: [],
+        configTypes: ['RecursiveMastPolicyStore', 'MirrorResult', 'MemoryPolicyStore', 'MemoryStoreOptions', 'HttpPolicyStore', 'HttpStoreOptions'],
+        package: 'recursive-mast',
+        keywords: ['policy store', 'memory store', 'http store', 'storage', 'mirror', 'policy persistence', 'policy storage'],
+        description: 'Policy store interface with in-memory and HTTP implementations — storage-agnostic persistence for policy trees, proofs, and manifests',
+    },
+    {
+        template: 'recursive-mast-encrypted-branch',
+        functions: ['createEncryptedBranch', 'decryptBranch', 'isEncryptedBranch', 'encryptedBranchPublicMetadata'],
+        configTypes: ['EncryptedBranchPackage', 'DecryptedBranchResult'],
+        package: 'recursive-mast',
+        keywords: ['encrypted branch', 'private policy', 'decrypt', 'confidential', 'encrypted mast', 'private script'],
+        description: 'Encrypted branch packages — private policy branches with public metadata, encryption, and decryption for confidential MAST structures',
+    },
+    {
+        template: 'recursive-mast-inventory',
+        functions: ['computeBranchInventoryHash', 'getCriticalBranches', 'getRecoveryBranches', 'getBranchesByAction', 'getBranchesByRole', 'validateInventoryCoverage'],
+        configTypes: ['BranchInventory', 'BranchInventoryEntry'],
+        package: 'recursive-mast',
+        keywords: ['branch inventory', 'critical branches', 'recovery branches', 'inventory hash', 'coverage validation', 'branch audit'],
+        description: 'Branch inventory management — compute inventory hashes, categorize branches by criticality, recovery, action, and role, and validate inventory coverage',
+    },
+    {
+        template: 'recursive-mast-availability',
+        functions: ['auditPolicyAvailability', 'createAvailabilityReceipt', 'signAvailabilityReceipt', 'verifyAvailabilityReceipt', 'receiptCoversBranch', 'receiptCoversInventory'],
+        configTypes: ['AvailabilityPolicy', 'PolicyAvailabilityReport', 'AuditConfig', 'AvailabilityReceipt'],
+        package: 'recursive-mast',
+        keywords: ['availability audit', 'data availability', 'availability receipt', 'receipt verification', 'policy availability', 'availability report'],
+        description: 'Policy availability auditing and receipts — audit which policies, proofs, and branches are available, issue signed availability receipts, and verify coverage',
+    },
+    {
+        template: 'recursive-mast-content-keys',
+        functions: ['policyManifestKey', 'scriptKey', 'proofKey', 'bundleKey', 'parseContentKey', 'computeBundleHash', 'computeScriptHash'],
+        configTypes: ['ContentKey'],
+        package: 'recursive-mast',
+        keywords: ['content key', 'content addressed', 'key scheme', 'bundle hash', 'script hash', 'policy manifest key', 'content addressing'],
+        description: 'Content-addressed key scheme for policy artifacts — deterministic key generation for manifests, scripts, proofs, and bundles using SHA3-256',
+    },
+];
+const PACKAGE_TO_TEMPLATES = {};
+for (const entry of exports.TEMPLATE_CATALOG) {
+    const pkgs = Array.isArray(entry.package) ? entry.package : entry.package ? [entry.package] : [];
+    for (const pkg of pkgs) {
+        if (!PACKAGE_TO_TEMPLATES[pkg])
+            PACKAGE_TO_TEMPLATES[pkg] = [];
+        PACKAGE_TO_TEMPLATES[pkg].push(entry);
+    }
+}
+function getTemplatesForPackage(pkgName) {
+    return PACKAGE_TO_TEMPLATES[pkgName] || [];
+}
+function searchTemplates(query) {
+    const q = query.toLowerCase();
+    const scored = [];
+    for (const entry of exports.TEMPLATE_CATALOG) {
+        let score = 0;
+        for (const kw of entry.keywords) {
+            if (kw.includes(q) || q.includes(kw))
+                score += 3;
+        }
+        for (const fn of entry.functions) {
+            if (fn.toLowerCase().includes(q))
+                score += 2;
+        }
+        if (entry.description.toLowerCase().includes(q))
+            score += 1;
+        if (entry.template.includes(q))
+            score += 2;
+        if (score > 0)
+            scored.push({ entry, score });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.map(s => s.entry);
+}
+function getAllTemplates() {
+    return exports.TEMPLATE_CATALOG;
+}

package/dist/tools.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleToolCall = handleToolCall;
+const template_catalog_js_1 = require("./template-catalog.js");
 function handleToolCall(name, args, index) {
     switch (name) {
         case 'search-symbol': return searchSymbol(args, index);
@@ -11,6 +12,7 @@ function handleToolCall(name, args, index) {
         case 'scaffold-package': return scaffoldPackage(args);
         case 'package-stats': return packageStats(args, index);
         case 'list-exports': return listExports(args, index);
+        case 'suggest-template': return suggestTemplate(args);
         default: return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
     }
 }
@@ -338,6 +340,40 @@ function scaffoldPackage(args) {
             }],
     };
 }
+function suggestTemplate(args) {
+    const usecase = (args.usecase || '').toLowerCase();
+    if (!usecase) {
+        return { content: [{ type: 'text', text: 'usecase is required — describe what you want to do (e.g. "time-lock funds until a block height")' }], isError: true };
+    }
+    const results = (0, template_catalog_js_1.searchTemplates)(usecase);
+    if (results.length === 0) {
+        return { content: [{ type: 'text', text: `No templates found matching '${usecase}'. Try different keywords (e.g. "lock", "vote", "payment", "identity", "state machine").` }] };
+    }
+    const lines = [`Found ${results.length} template(s) matching '${args.usecase}':`, ''];
+    for (const r of results) {
+        lines.push(`## ${r.template}`);
+        lines.push(`${r.description}`);
+        lines.push('');
+        lines.push(`**Functions:**`);
+        for (const fn of r.functions) {
+            lines.push(`  - \`import { ${fn} } from '@totemsdk/kissvm'\``);
+        }
+        if (r.configTypes.length > 0) {
+            lines.push('');
+            lines.push(`**Config types:**`);
+            for (const t of r.configTypes) {
+                lines.push(`  - \`${t}\``);
+            }
+        }
+        if (r.package) {
+            const pkgs = Array.isArray(r.package) ? r.package : [r.package];
+            lines.push('');
+            lines.push(`**Related package(s):** ${pkgs.map(p => `\`@totemsdk/${p}\``).join(', ')}`);
+        }
+        lines.push('');
+    }
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
 function packageStats(args, index) {
     const pkgName = args.name;
     if (!pkgName || !index.packages[pkgName]) {
@@ -348,6 +384,18 @@ function packageStats(args, index) {
         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/'));
+    const pkgDir = pkg.name.replace('@totemsdk/', '');
+    const templates = (0, template_catalog_js_1.getTemplatesForPackage)(pkgDir);
+    const templateSection = templates.length > 0
+        ? [
+            ``,
+            `**KISSVM Templates:**`,
+            ...templates.flatMap(t => [
+                `  - **${t.template}** — ${t.description}`,
+                ...t.functions.map(fn => `    - \`import { ${fn} } from '@totemsdk/kissvm'\``),
+            ]),
+        ]
+        : [];
     return {
         content: [{
                 type: 'text',
@@ -371,6 +419,7 @@ function packageStats(args, index) {
                     `| Tests | ${pkg.hasTests ? 'Yes' : 'No'} |`,
                     `| @totemsdk/* deps | ${totemDeps.length} |`,
                     `| External deps | ${externalDeps.length} |`,
+                    ...templateSection,
                     ``,
                 ].join('\n'),
             }],

package/package.json

@@ -1,7 +1,7 @@
 {
   "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",
+  "version": "0.2.0",
+  "description": "MCP server exposing the full Totem SDK package set — metadata, types, exports, dependency graphs, and scaffolding tools for 55 packages",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
@@ -14,18 +14,19 @@
       "import": "./dist/index.js"
     }
   },
-  "scripts": {
-    "build": "tsc",
-    "prepare": "",
-    "clean": "rm -rf dist",
-    "start": "node dist/index.js"
-  },
-  "files": ["dist", "README.md", "LICENSE"],
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0"
+    "@modelcontextprotocol/sdk": "^1.30.0"
   },
   "devDependencies": {
+    "@types/jest": "^30.0.0",
     "@types/node": "^20.0.0",
+    "jest": "^30.4.2",
+    "ts-jest": "^29.0.0",
     "typescript": "^7.0.2"
   },
   "engines": {
@@ -38,12 +39,24 @@
   "author": "Totem SDK",
   "homepage": "https://totem.ing",
   "bugs": {
-    "url": "https://github.com/totem-sdk/totem-sdk/issues"
+    "url": "https://github.com/Totem-Edge/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"]
-}
+    "url": "git+https://github.com/Totem-Edge/totem-sdk.git",
+    "directory": "packages/mcp-server"
+  },
+  "keywords": [
+    "totem",
+    "totemsdk",
+    "mcp",
+    "model-context-protocol",
+    "sdk-index"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "start": "node dist/index.js",
+    "test": "jest"
+  }
+}