@dollhousemcp/mcp-server
Version:
DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.
279 lines (277 loc) • 33.9 kB
JavaScript
/**
* Capability Index Resource Handler
*
* Exposes the capability index as an MCP resource for injection into LLM context.
* Provides both summary (action_triggers only) and full index variants.
*
* ⚠️ MERGE STATUS: PORTED BUT NOT INTEGRATED (October 2025)
*
* This file was ported from main branch (v1.9.18-v1.9.24) but is NOT currently
* integrated into the refactored DI architecture. Integration is planned for a
* future phase once the Enhanced Index system is fully operational.
*
* CURRENT STATE:
* - ✅ File ported and preserved for future use
* - ❌ NOT registered in DI Container
* - ❌ NOT registered with MCP server
* - ❌ NOT accessible to users
*
* ⚠️ ORIGINAL STATUS: NON-FUNCTIONAL IN CLAUDE CODE (October 2025)
*
* This is a FUTURE-PROOF implementation. MCP Resources are currently:
* - ✅ Fully implemented and MCP specification compliant
* - ❌ NOT working in Claude Code (discovery only, never read)
* - ⚠️ Manual attachment only in Claude Desktop/VS Code
*
* WHY IMPLEMENT NOW?
* - Early adopter advantage when clients add full support
* - Manual attachment works in Claude Desktop/VS Code
* - Zero overhead when disabled (default configuration)
*
* DEFAULT: DISABLED FOR SAFETY
* Resources are disabled by default to avoid token overhead and ensure
* no surprises for users. Must be explicitly enabled in configuration.
*
* WHEN WILL THIS BE USEFUL?
* When Claude Code and other MCP clients implement the missing
* resources/read functionality and automatic resource injection.
* Expected timeline: Unknown.
*
* For detailed research, see:
* docs/development/MCP_RESOURCES_SUPPORT_RESEARCH_2025-10-16.md
*
* For user documentation, see:
* docs/configuration/MCP_RESOURCES.md
*
* FUTURE INTEGRATION TASKS:
* - [ ] Register in DI Container (src/di/Container.ts)
* - [ ] Add configuration option for enabling resources
* - [ ] Register resource handlers with MCP server when enabled
* - [ ] Add unit tests for resource generation
* - [ ] Add integration tests for MCP resource protocol
*/
// FIX: Added node: prefix to built-in Node.js imports
// Previously: import fs from 'fs/promises'; etc.
// Now: import fs from 'node:fs/promises'; for Node.js convention
import path from 'node:path';
import yaml from 'js-yaml';
import os from 'node:os';
import { logger } from '../../utils/logger.js';
/**
* Capability Index Resource Handler
*
* Provides three MCP resources:
* 1. Summary (~2.5-3.5K tokens) - action_triggers only
* 2. Full (~35-45K tokens) - complete index with all details
* 3. Stats (JSON) - size metrics and token estimates
*
* WHY DISABLED BY DEFAULT:
* 1. Current MCP clients don't actually read resources (Claude Code discovery only)
* 2. Avoids unexpected token overhead when clients do implement reading
* 3. Provides opt-in behavior for users who want to test manually in Claude Desktop
*
* TO ENABLE:
* Set in config: resources.enabled = true
* Or environment: DOLLHOUSE_RESOURCES_ENABLED=true
*
* NOTE: This class always provides resource handlers for MCP protocol compliance,
* but the resources are only registered with the MCP server if explicitly enabled.
*/
export class CapabilityIndexResource {
capabilityIndexPath;
cachedIndex = null;
cacheTimestamp = 0;
CACHE_TTL = 60000; // 60 seconds
fileOperations;
constructor(fileOperations) {
this.fileOperations = fileOperations;
// Respect environment variable if set (for testing), otherwise use default
const portfolioDir = process.env.DOLLHOUSE_PORTFOLIO_DIR
|| path.join(os.homedir(), '.dollhouse', 'portfolio');
this.capabilityIndexPath = path.join(portfolioDir, 'capability-index.yaml');
}
/**
* Load and parse capability index from filesystem
* Uses 60-second cache to avoid excessive file reads
*
* @returns Parsed capability index
* @throws Error if file cannot be read or parsed
*/
async loadCapabilityIndex() {
const now = Date.now();
// Return cached version if still valid
if (this.cachedIndex && (now - this.cacheTimestamp) < this.CACHE_TTL) {
return this.cachedIndex;
}
try {
// Check if file exists
const fileExists = await this.fileOperations.exists(this.capabilityIndexPath);
if (!fileExists) {
throw new Error(`Capability index not found at ${this.capabilityIndexPath}`);
}
// Read and parse YAML with safe schema to prevent code execution
const content = await this.fileOperations.readFile(this.capabilityIndexPath, {
source: 'CapabilityIndexResource.loadCapabilityIndex'
});
const parsed = yaml.load(content, { schema: yaml.FAILSAFE_SCHEMA });
// Cache the result
this.cachedIndex = parsed;
this.cacheTimestamp = now;
logger.info(`Loaded capability index: ${parsed.metadata.total_elements} elements`);
return parsed;
}
catch (error) {
const errorMessage = error instanceof Error ? error.message : String(error);
logger.error(`Failed to load capability index: ${errorMessage}`);
throw new Error(`Capability index not available: ${errorMessage}`);
}
}
/**
* Generate summary version of capability index (metadata + action_triggers only)
* Estimated: 2,500-3,500 tokens
*
* @returns YAML string with header and summary content
*/
async generateSummary() {
const index = await this.loadCapabilityIndex();
const summary = {
metadata: index.metadata,
action_triggers: index.action_triggers
};
// Convert to YAML for readability
const yamlContent = yaml.dump(summary, {
indent: 2,
lineWidth: 120,
noRefs: true
});
// Add header comment
const header = `# Capability Index Summary
# This is a lightweight summary of the capability index for LLM context injection.
# Contains action verb → element mappings for quick tool selection guidance.
# Full index available at: dollhouse://capability-index/full
# Total elements: ${index.metadata.total_elements}
`;
return header + yamlContent;
}
/**
* Generate full capability index
* Estimated: 35,000-45,000 tokens
*
* @returns YAML string with header and full index content
*/
async generateFull() {
const index = await this.loadCapabilityIndex();
// Convert to YAML for readability
const yamlContent = yaml.dump(index, {
indent: 2,
lineWidth: 120,
noRefs: true
});
// Add header comment
const header = `# Capability Index (Full)
# Complete capability index including all element details, relationships, and semantic data.
# This is a large resource (~35-45K tokens) - use only with large context models.
# Summary version available at: dollhouse://capability-index/summary
# Total elements: ${index.metadata.total_elements}
`;
return header + yamlContent;
}
/**
* Get statistics about the capability index for measurement
* Provides size metrics and rough token estimates using:
* (chars/4 + words*1.3)/2 formula
*
* @returns Statistics object with size and token estimates
*/
async getStatistics() {
const summary = await this.generateSummary();
const full = await this.generateFull();
return {
summarySize: summary.length,
summaryWords: summary.split(/\s+/).length,
summaryLines: summary.split('\n').length,
fullSize: full.length,
fullWords: full.split(/\s+/).length,
fullLines: full.split('\n').length,
// Rough token estimates (chars/4 + words*1.3)/2
estimatedSummaryTokens: Math.round((summary.length / 4 + summary.split(/\s+/).length * 1.3) / 2),
estimatedFullTokens: Math.round((full.length / 4 + full.split(/\s+/).length * 1.3) / 2)
};
}
/**
* MCP Resource Handler: List available resources
*
* Returns three resources:
* - summary: Lightweight index (~2.5-3.5K tokens)
* - full: Complete index (~35-45K tokens)
* - stats: Size and token metrics (JSON)
*
* @returns Resource list with URIs, names, descriptions, and MIME types
*/
async listResources() {
return {
resources: [
{
uri: 'dollhouse://capability-index/summary',
name: 'Capability Index Summary',
description: 'Lightweight capability index with action verb → element mappings. Estimated ~2.5-3.5K tokens. Recommended for models with 200K+ context.',
mimeType: 'text/yaml'
},
{
uri: 'dollhouse://capability-index/full',
name: 'Capability Index (Full)',
description: 'Complete capability index with all element details, relationships, and semantic data. Estimated ~35-45K tokens. Recommended for models with 500K+ context.',
mimeType: 'text/yaml'
},
{
uri: 'dollhouse://capability-index/stats',
name: 'Capability Index Statistics',
description: 'Measurement data about capability index size and token estimates.',
mimeType: 'application/json'
}
]
};
}
/**
* MCP Resource Handler: Read a specific resource
*
* @param uri - Resource URI to read (must match one from listResources)
* @returns Resource content with URI, MIME type, and text
* @throws Error if URI is not recognized
*/
async readResource(uri) {
let content;
let mimeType;
switch (uri) {
case 'dollhouse://capability-index/summary':
content = await this.generateSummary();
mimeType = 'text/yaml';
break;
case 'dollhouse://capability-index/full':
content = await this.generateFull();
mimeType = 'text/yaml';
break;
case 'dollhouse://capability-index/stats': {
// FIX: Wrapped lexical declaration in curly braces
// Previously: const declaration in case block without braces
// Now: Properly scoped with block statement
const stats = await this.getStatistics();
content = JSON.stringify(stats, null, 2);
mimeType = 'application/json';
break;
}
default:
throw new Error(`Unknown capability index resource: ${uri}`);
}
return {
contents: [
{
uri,
mimeType,
text: content
}
]
};
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CapabilityIndexResource.js","sourceRoot":"","sources":["../../../src/server/resources/CapabilityIndexResource.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Capability Index Resource Handler\n *\n * Exposes the capability index as an MCP resource for injection into LLM context.\n * Provides both summary (action_triggers only) and full index variants.\n *\n * ⚠️ MERGE STATUS: PORTED BUT NOT INTEGRATED (October 2025)\n *\n * This file was ported from main branch (v1.9.18-v1.9.24) but is NOT currently\n * integrated into the refactored DI architecture. Integration is planned for a\n * future phase once the Enhanced Index system is fully operational.\n *\n * CURRENT STATE:\n * - ✅ File ported and preserved for future use\n * - ❌ NOT registered in DI Container\n * - ❌ NOT registered with MCP server\n * - ❌ NOT accessible to users\n *\n * ⚠️ ORIGINAL STATUS: NON-FUNCTIONAL IN CLAUDE CODE (October 2025)\n *\n * This is a FUTURE-PROOF implementation. MCP Resources are currently:\n * - ✅ Fully implemented and MCP specification compliant\n * - ❌ NOT working in Claude Code (discovery only, never read)\n * - ⚠️ Manual attachment only in Claude Desktop/VS Code\n *\n * WHY IMPLEMENT NOW?\n * - Early adopter advantage when clients add full support\n * - Manual attachment works in Claude Desktop/VS Code\n * - Zero overhead when disabled (default configuration)\n *\n * DEFAULT: DISABLED FOR SAFETY\n * Resources are disabled by default to avoid token overhead and ensure\n * no surprises for users. Must be explicitly enabled in configuration.\n *\n * WHEN WILL THIS BE USEFUL?\n * When Claude Code and other MCP clients implement the missing\n * resources/read functionality and automatic resource injection.\n * Expected timeline: Unknown.\n *\n * For detailed research, see:\n * docs/development/MCP_RESOURCES_SUPPORT_RESEARCH_2025-10-16.md\n *\n * For user documentation, see:\n * docs/configuration/MCP_RESOURCES.md\n *\n * FUTURE INTEGRATION TASKS:\n * - [ ] Register in DI Container (src/di/Container.ts)\n * - [ ] Add configuration option for enabling resources\n * - [ ] Register resource handlers with MCP server when enabled\n * - [ ] Add unit tests for resource generation\n * - [ ] Add integration tests for MCP resource protocol\n */\n\n// FIX: Added node: prefix to built-in Node.js imports\n// Previously: import fs from 'fs/promises'; etc.\n// Now: import fs from 'node:fs/promises'; for Node.js convention\nimport path from 'node:path';\nimport yaml from 'js-yaml';\nimport os from 'node:os';\nimport { logger } from '../../utils/logger.js';\nimport { IFileOperationsService } from '../../services/FileOperationsService.js';\n\n/**\n * Metadata about the capability index\n */\ninterface CapabilityIndexMetadata {\n  version: string;\n  created: string;\n  last_updated: string;\n  total_elements: number;\n}\n\n/**\n * Full capability index structure\n */\ninterface CapabilityIndex {\n  metadata: CapabilityIndexMetadata;\n  action_triggers: Record<string, string[]>;\n  elements?: any; // Large section we might exclude in summary\n}\n\n/**\n * Statistics about the capability index size and token estimates\n */\ninterface CapabilityIndexStatistics {\n  summarySize: number;\n  summaryWords: number;\n  summaryLines: number;\n  fullSize: number;\n  fullWords: number;\n  fullLines: number;\n  estimatedSummaryTokens: number;\n  estimatedFullTokens: number;\n}\n\n/**\n * MCP Resource structure\n */\ninterface MCPResource {\n  uri: string;\n  name: string;\n  description: string;\n  mimeType: string;\n}\n\n/**\n * MCP Resource list response\n */\ninterface MCPResourceListResponse {\n  resources: MCPResource[];\n}\n\n/**\n * MCP Resource content item\n */\ninterface MCPResourceContent {\n  uri: string;\n  mimeType: string;\n  text: string;\n}\n\n/**\n * MCP Resource read response\n */\ninterface MCPResourceReadResponse {\n  contents: MCPResourceContent[];\n}\n\n/**\n * Capability Index Resource Handler\n *\n * Provides three MCP resources:\n * 1. Summary (~2.5-3.5K tokens) - action_triggers only\n * 2. Full (~35-45K tokens) - complete index with all details\n * 3. Stats (JSON) - size metrics and token estimates\n *\n * WHY DISABLED BY DEFAULT:\n * 1. Current MCP clients don't actually read resources (Claude Code discovery only)\n * 2. Avoids unexpected token overhead when clients do implement reading\n * 3. Provides opt-in behavior for users who want to test manually in Claude Desktop\n *\n * TO ENABLE:\n * Set in config: resources.enabled = true\n * Or environment: DOLLHOUSE_RESOURCES_ENABLED=true\n *\n * NOTE: This class always provides resource handlers for MCP protocol compliance,\n * but the resources are only registered with the MCP server if explicitly enabled.\n */\nexport class CapabilityIndexResource {\n  private readonly capabilityIndexPath: string;\n  private cachedIndex: CapabilityIndex | null = null;\n  private cacheTimestamp: number = 0;\n  private readonly CACHE_TTL = 60000; // 60 seconds\n  private readonly fileOperations: IFileOperationsService;\n\n  constructor(fileOperations: IFileOperationsService) {\n    this.fileOperations = fileOperations;\n\n    // Respect environment variable if set (for testing), otherwise use default\n    const portfolioDir = process.env.DOLLHOUSE_PORTFOLIO_DIR\n      || path.join(os.homedir(), '.dollhouse', 'portfolio');\n\n    this.capabilityIndexPath = path.join(\n      portfolioDir,\n      'capability-index.yaml'\n    );\n  }\n\n  /**\n   * Load and parse capability index from filesystem\n   * Uses 60-second cache to avoid excessive file reads\n   *\n   * @returns Parsed capability index\n   * @throws Error if file cannot be read or parsed\n   */\n  private async loadCapabilityIndex(): Promise<CapabilityIndex> {\n    const now = Date.now();\n\n    // Return cached version if still valid\n    if (this.cachedIndex && (now - this.cacheTimestamp) < this.CACHE_TTL) {\n      return this.cachedIndex;\n    }\n\n    try {\n      // Check if file exists\n      const fileExists = await this.fileOperations.exists(this.capabilityIndexPath);\n      if (!fileExists) {\n        throw new Error(`Capability index not found at ${this.capabilityIndexPath}`);\n      }\n\n      // Read and parse YAML with safe schema to prevent code execution\n      const content = await this.fileOperations.readFile(this.capabilityIndexPath, {\n        source: 'CapabilityIndexResource.loadCapabilityIndex'\n      });\n      const parsed = yaml.load(content, { schema: yaml.FAILSAFE_SCHEMA }) as CapabilityIndex;\n\n      // Cache the result\n      this.cachedIndex = parsed;\n      this.cacheTimestamp = now;\n\n      logger.info(`Loaded capability index: ${parsed.metadata.total_elements} elements`);\n\n      return parsed;\n    } catch (error) {\n      const errorMessage = error instanceof Error ? error.message : String(error);\n      logger.error(`Failed to load capability index: ${errorMessage}`);\n      throw new Error(`Capability index not available: ${errorMessage}`);\n    }\n  }\n\n  /**\n   * Generate summary version of capability index (metadata + action_triggers only)\n   * Estimated: 2,500-3,500 tokens\n   *\n   * @returns YAML string with header and summary content\n   */\n  async generateSummary(): Promise<string> {\n    const index = await this.loadCapabilityIndex();\n\n    const summary = {\n      metadata: index.metadata,\n      action_triggers: index.action_triggers\n    };\n\n    // Convert to YAML for readability\n    const yamlContent = yaml.dump(summary, {\n      indent: 2,\n      lineWidth: 120,\n      noRefs: true\n    });\n\n    // Add header comment\n    const header = `# Capability Index Summary\n# This is a lightweight summary of the capability index for LLM context injection.\n# Contains action verb → element mappings for quick tool selection guidance.\n# Full index available at: dollhouse://capability-index/full\n# Total elements: ${index.metadata.total_elements}\n\n`;\n\n    return header + yamlContent;\n  }\n\n  /**\n   * Generate full capability index\n   * Estimated: 35,000-45,000 tokens\n   *\n   * @returns YAML string with header and full index content\n   */\n  async generateFull(): Promise<string> {\n    const index = await this.loadCapabilityIndex();\n\n    // Convert to YAML for readability\n    const yamlContent = yaml.dump(index, {\n      indent: 2,\n      lineWidth: 120,\n      noRefs: true\n    });\n\n    // Add header comment\n    const header = `# Capability Index (Full)\n# Complete capability index including all element details, relationships, and semantic data.\n# This is a large resource (~35-45K tokens) - use only with large context models.\n# Summary version available at: dollhouse://capability-index/summary\n# Total elements: ${index.metadata.total_elements}\n\n`;\n\n    return header + yamlContent;\n  }\n\n  /**\n   * Get statistics about the capability index for measurement\n   * Provides size metrics and rough token estimates using:\n   * (chars/4 + words*1.3)/2 formula\n   *\n   * @returns Statistics object with size and token estimates\n   */\n  async getStatistics(): Promise<CapabilityIndexStatistics> {\n    const summary = await this.generateSummary();\n    const full = await this.generateFull();\n\n    return {\n      summarySize: summary.length,\n      summaryWords: summary.split(/\\s+/).length,\n      summaryLines: summary.split('\\n').length,\n      fullSize: full.length,\n      fullWords: full.split(/\\s+/).length,\n      fullLines: full.split('\\n').length,\n      // Rough token estimates (chars/4 + words*1.3)/2\n      estimatedSummaryTokens: Math.round((summary.length / 4 + summary.split(/\\s+/).length * 1.3) / 2),\n      estimatedFullTokens: Math.round((full.length / 4 + full.split(/\\s+/).length * 1.3) / 2)\n    };\n  }\n\n  /**\n   * MCP Resource Handler: List available resources\n   *\n   * Returns three resources:\n   * - summary: Lightweight index (~2.5-3.5K tokens)\n   * - full: Complete index (~35-45K tokens)\n   * - stats: Size and token metrics (JSON)\n   *\n   * @returns Resource list with URIs, names, descriptions, and MIME types\n   */\n  async listResources(): Promise<MCPResourceListResponse> {\n    return {\n      resources: [\n        {\n          uri: 'dollhouse://capability-index/summary',\n          name: 'Capability Index Summary',\n          description: 'Lightweight capability index with action verb → element mappings. Estimated ~2.5-3.5K tokens. Recommended for models with 200K+ context.',\n          mimeType: 'text/yaml'\n        },\n        {\n          uri: 'dollhouse://capability-index/full',\n          name: 'Capability Index (Full)',\n          description: 'Complete capability index with all element details, relationships, and semantic data. Estimated ~35-45K tokens. Recommended for models with 500K+ context.',\n          mimeType: 'text/yaml'\n        },\n        {\n          uri: 'dollhouse://capability-index/stats',\n          name: 'Capability Index Statistics',\n          description: 'Measurement data about capability index size and token estimates.',\n          mimeType: 'application/json'\n        }\n      ]\n    };\n  }\n\n  /**\n   * MCP Resource Handler: Read a specific resource\n   *\n   * @param uri - Resource URI to read (must match one from listResources)\n   * @returns Resource content with URI, MIME type, and text\n   * @throws Error if URI is not recognized\n   */\n  async readResource(uri: string): Promise<MCPResourceReadResponse> {\n    let content: string;\n    let mimeType: string;\n\n    switch (uri) {\n      case 'dollhouse://capability-index/summary':\n        content = await this.generateSummary();\n        mimeType = 'text/yaml';\n        break;\n\n      case 'dollhouse://capability-index/full':\n        content = await this.generateFull();\n        mimeType = 'text/yaml';\n        break;\n\n      case 'dollhouse://capability-index/stats': {\n        // FIX: Wrapped lexical declaration in curly braces\n        // Previously: const declaration in case block without braces\n        // Now: Properly scoped with block statement\n        const stats = await this.getStatistics();\n        content = JSON.stringify(stats, null, 2);\n        mimeType = 'application/json';\n        break;\n      }\n\n      default:\n        throw new Error(`Unknown capability index resource: ${uri}`);\n    }\n\n    return {\n      contents: [\n        {\n          uri,\n          mimeType,\n          text: content\n        }\n      ]\n    };\n  }\n}\n"]}