@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.
225 lines • 31.9 kB
JavaScript
/**
* upgradeElement - Upgrade element from v1 single-body to v2 dual-field format
*
* v1 format: Body text after YAML frontmatter, no `instructions` key in YAML
* v2 format: `instructions` in YAML frontmatter, `content` as markdown body
*
* Detection: If YAML frontmatter contains `instructions` key → already v2.
* Otherwise → v1, apply per-type default mapping.
*
* @see Plan: Dual-Field Element Architecture
*/
import { ElementType } from '../../portfolio/PortfolioManager.js';
import { logger } from '../../utils/logger.js';
import { ElementNotFoundError } from '../../utils/ErrorHandler.js';
import { normalizeElementTypeInput, formatValidElementTypesList, getElementTypeLabel, resolveElementByName, } from './helpers.js';
/**
* Per-type default mapping for v1 body text.
* Returns which field the body text should be assigned to.
*/
function getV1BodyMapping(elementType) {
switch (elementType) {
case ElementType.PERSONA:
case ElementType.SKILL:
case ElementType.AGENT:
return 'instructions';
case ElementType.TEMPLATE:
case ElementType.MEMORY:
case ElementType.ENSEMBLE:
return 'content';
default:
return 'content';
}
}
/**
* Detect whether an element is in v2 dual-field format.
*
* v2 indicators vary by element type:
* - For persona/skill/agent (body→instructions): v2 means instructions were in
* YAML frontmatter. If both instructions AND content are populated, it's
* definitively v2. If only instructions is populated (no content), it COULD be
* v1 (body→instructions) or v2 (instructions in YAML, empty body). Since we
* can't distinguish after loading, we treat instructions-only as v1 — the
* re-save is safe either way (it just writes v2 format to disk).
* - For template/memory/ensemble (body→content): v2 means instructions were added
* (since v1 would have empty instructions). Any non-empty instructions = v2.
*/
function isV2Format(element, elementType) {
const bodyMapping = getV1BodyMapping(elementType);
const instructions = (element.instructions || '').trim();
const content = getElementContent(element);
if (bodyMapping === 'instructions') {
// Persona/Skill/Agent: v1 has body→instructions (content empty).
// v2 has instructions in YAML frontmatter AND content as markdown body.
// Instructions-only (no content) is ambiguous — treated as v1, which is safe:
// the re-save writes v2 format without changing field values.
return instructions.length > 0 && content.length > 0;
}
else {
// Template/Memory/Ensemble: v1 has body→content (instructions empty).
// v2 has instructions in YAML AND content as body.
return instructions.length > 0;
}
}
/**
* Get content from element, handling Memory's getter pattern.
*/
function getElementContent(element) {
return (typeof element.content === 'string' ? element.content : '').trim();
}
/**
* Upgrade an element from v1 single-body format to v2 dual-field format.
*/
export async function upgradeElement(context, args) {
await context.ensureInitialized();
const { name, type, dry_run, instructions_override, content_override } = args;
if (!name) {
return error('Missing required parameter: element_name');
}
const { type: normalizedType } = normalizeElementTypeInput(type);
if (!normalizedType) {
return error(`Invalid element type '${type}'. Valid types: ${formatValidElementTypesList()}`);
}
const manager = getManagerForType(context, normalizedType);
if (!manager) {
const label = getElementTypeLabel(normalizedType, { plural: true });
return error(`Element type '${label}' is not yet supported for upgrade`);
}
const element = await resolveElementByName(manager, normalizedType, name);
if (!element) {
const label = getElementTypeLabel(normalizedType);
throw new ElementNotFoundError(label, name);
}
const currentInstructions = (element.instructions || '').trim();
const currentContent = getElementContent(element);
// Check if already v2 format (and no overrides provided)
if (isV2Format(element, normalizedType) && !instructions_override && !content_override) {
return {
content: [{
type: 'text',
text: `ℹ️ ${getElementTypeLabel(normalizedType)} '${element.metadata?.name || name}' is already in v2 dual-field format.\n\n` +
`**Instructions** (${currentInstructions.length} chars): ${truncate(currentInstructions, 100)}\n` +
`**Content** (${currentContent.length} chars): ${truncate(currentContent, 100)}`
}]
};
}
// Determine new field values
let newInstructions;
let newContent;
if (instructions_override !== undefined || content_override !== undefined) {
// Manual override mode
newInstructions = instructions_override ?? currentInstructions;
newContent = content_override ?? currentContent;
}
else {
// Auto-detection: field values stay the same — the managers already assigned the
// body text to the correct field during load (per getV1BodyMapping). The upgrade
// is the re-save itself: serializeElement() writes instructions to YAML frontmatter
// and content as the markdown body, converting the on-disk format from v1 to v2.
newInstructions = currentInstructions;
newContent = currentContent;
}
if (dry_run) {
// Preview mode — show what would change
const changes = [];
if (newInstructions !== currentInstructions) {
changes.push(`**instructions**: "${truncate(currentInstructions, 80)}" → "${truncate(newInstructions, 80)}"`);
}
if (newContent !== currentContent) {
changes.push(`**content**: "${truncate(currentContent, 80)}" → "${truncate(newContent, 80)}"`);
}
const displayName = element.metadata?.name || name;
const label = getElementTypeLabel(normalizedType);
if (changes.length === 0) {
return {
content: [{
type: 'text',
text: `ℹ️ ${label} '${displayName}' — no field changes needed for upgrade.\n\n` +
`The file will be re-saved in v2 format (instructions in YAML frontmatter, content as body).\n\n` +
`**instructions** (${newInstructions.length} chars): ${truncate(newInstructions, 150)}\n` +
`**content** (${newContent.length} chars): ${truncate(newContent, 150)}`
}]
};
}
return {
content: [{
type: 'text',
text: `🔍 Dry run — ${label} '${displayName}' upgrade preview:\n\n` +
changes.join('\n') + '\n\n' +
`Run without dry_run to apply these changes.`
}]
};
}
// Apply upgrade
element.instructions = newInstructions;
// For Memory, content is a getter — skip direct assignment
if (normalizedType !== ElementType.MEMORY) {
element.content = newContent;
}
// Determine file path for saving
const filePathCandidate = typeof element.getFilePath === 'function'
? element.getFilePath()
: (element.filePath || element.filename);
const filename = typeof filePathCandidate === 'string' && filePathCandidate.length > 0
? filePathCandidate
: '';
if (!filename) {
return error(`Cannot determine file path for ${getElementTypeLabel(normalizedType)} '${name}'`);
}
try {
await manager.save(element, filename);
}
catch (err) {
return error(`Failed to save upgraded element: ${err instanceof Error ? err.message : 'Unknown error'}`);
}
const displayName = element.metadata?.name || name;
const label = getElementTypeLabel(normalizedType);
logger.info(`[upgradeElement] Upgraded ${label} '${displayName}' to v2 dual-field format`, {
elementType: normalizedType,
elementName: displayName,
instructionsLength: newInstructions.length,
contentLength: newContent.length,
});
return {
content: [{
type: 'text',
text: `✅ Upgraded ${label} '${displayName}' to v2 dual-field format.\n\n` +
`**instructions** (${newInstructions.length} chars): ${truncate(newInstructions, 150)}\n` +
`**content** (${newContent.length} chars): ${truncate(newContent, 150)}`
}]
};
}
function error(message) {
return {
content: [{
type: 'text',
text: `❌ ${message}`
}]
};
}
function truncate(text, maxLength) {
if (!text)
return '(empty)';
if (text.length <= maxLength)
return text;
return text.slice(0, maxLength) + '...';
}
function getManagerForType(context, type) {
switch (type) {
case ElementType.PERSONA:
return context.personaManager;
case ElementType.SKILL:
return context.skillManager;
case ElementType.TEMPLATE:
return context.templateManager;
case ElementType.AGENT:
return context.agentManager;
case ElementType.MEMORY:
return context.memoryManager;
case ElementType.ENSEMBLE:
return context.ensembleManager;
default:
return null;
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upgradeElement.js","sourceRoot":"","sources":["../../../src/handlers/element-crud/upgradeElement.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * upgradeElement - Upgrade element from v1 single-body to v2 dual-field format\n *\n * v1 format: Body text after YAML frontmatter, no `instructions` key in YAML\n * v2 format: `instructions` in YAML frontmatter, `content` as markdown body\n *\n * Detection: If YAML frontmatter contains `instructions` key → already v2.\n * Otherwise → v1, apply per-type default mapping.\n *\n * @see Plan: Dual-Field Element Architecture\n */\n\nimport { ElementType } from '../../portfolio/PortfolioManager.js';\nimport { ElementCrudContext } from './types.js';\nimport { logger } from '../../utils/logger.js';\nimport { ElementNotFoundError } from '../../utils/ErrorHandler.js';\nimport {\n  normalizeElementTypeInput,\n  formatValidElementTypesList,\n  getElementTypeLabel,\n  resolveElementByName,\n  ElementManagerOperations,\n} from './helpers.js';\n\ntype ElementManagerWithPersistence<T> = ElementManagerOperations<T> & {\n  save(element: T, filePath: string): Promise<void>;\n};\n\nexport interface UpgradeElementArgs {\n  name: string;\n  type: string;\n  /** Preview changes without writing to disk */\n  dry_run?: boolean;\n  /** Manually specify instructions (overrides auto-detection) */\n  instructions_override?: string;\n  /** Manually specify content (overrides auto-detection) */\n  content_override?: string;\n}\n\n/**\n * Per-type default mapping for v1 body text.\n * Returns which field the body text should be assigned to.\n */\nfunction getV1BodyMapping(elementType: ElementType): 'instructions' | 'content' {\n  switch (elementType) {\n    case ElementType.PERSONA:\n    case ElementType.SKILL:\n    case ElementType.AGENT:\n      return 'instructions';\n    case ElementType.TEMPLATE:\n    case ElementType.MEMORY:\n    case ElementType.ENSEMBLE:\n      return 'content';\n    default:\n      return 'content';\n  }\n}\n\n/**\n * Detect whether an element is in v2 dual-field format.\n *\n * v2 indicators vary by element type:\n * - For persona/skill/agent (body→instructions): v2 means instructions were in\n *   YAML frontmatter. If both instructions AND content are populated, it's\n *   definitively v2. If only instructions is populated (no content), it COULD be\n *   v1 (body→instructions) or v2 (instructions in YAML, empty body). Since we\n *   can't distinguish after loading, we treat instructions-only as v1 — the\n *   re-save is safe either way (it just writes v2 format to disk).\n * - For template/memory/ensemble (body→content): v2 means instructions were added\n *   (since v1 would have empty instructions). Any non-empty instructions = v2.\n */\nfunction isV2Format(element: any, elementType: ElementType): boolean {\n  const bodyMapping = getV1BodyMapping(elementType);\n  const instructions = (element.instructions || '').trim();\n  const content = getElementContent(element);\n\n  if (bodyMapping === 'instructions') {\n    // Persona/Skill/Agent: v1 has body→instructions (content empty).\n    // v2 has instructions in YAML frontmatter AND content as markdown body.\n    // Instructions-only (no content) is ambiguous — treated as v1, which is safe:\n    // the re-save writes v2 format without changing field values.\n    return instructions.length > 0 && content.length > 0;\n  } else {\n    // Template/Memory/Ensemble: v1 has body→content (instructions empty).\n    // v2 has instructions in YAML AND content as body.\n    return instructions.length > 0;\n  }\n}\n\n/**\n * Get content from element, handling Memory's getter pattern.\n */\nfunction getElementContent(element: any): string {\n  return (typeof element.content === 'string' ? element.content : '').trim();\n}\n\n/**\n * Upgrade an element from v1 single-body format to v2 dual-field format.\n */\nexport async function upgradeElement(\n  context: ElementCrudContext,\n  args: UpgradeElementArgs,\n) {\n  await context.ensureInitialized();\n\n  const { name, type, dry_run, instructions_override, content_override } = args;\n\n  if (!name) {\n    return error('Missing required parameter: element_name');\n  }\n\n  const { type: normalizedType } = normalizeElementTypeInput(type);\n  if (!normalizedType) {\n    return error(`Invalid element type '${type}'. Valid types: ${formatValidElementTypesList()}`);\n  }\n\n  const manager = getManagerForType(context, normalizedType);\n  if (!manager) {\n    const label = getElementTypeLabel(normalizedType, { plural: true });\n    return error(`Element type '${label}' is not yet supported for upgrade`);\n  }\n\n  const element = await resolveElementByName(manager, normalizedType, name);\n  if (!element) {\n    const label = getElementTypeLabel(normalizedType);\n    throw new ElementNotFoundError(label, name);\n  }\n\n  const currentInstructions = ((element as any).instructions || '').trim();\n  const currentContent = getElementContent(element);\n\n  // Check if already v2 format (and no overrides provided)\n  if (isV2Format(element, normalizedType) && !instructions_override && !content_override) {\n    return {\n      content: [{\n        type: 'text',\n        text: `ℹ️ ${getElementTypeLabel(normalizedType)} '${(element as any).metadata?.name || name}' is already in v2 dual-field format.\\n\\n` +\n          `**Instructions** (${currentInstructions.length} chars): ${truncate(currentInstructions, 100)}\\n` +\n          `**Content** (${currentContent.length} chars): ${truncate(currentContent, 100)}`\n      }]\n    };\n  }\n\n  // Determine new field values\n  let newInstructions: string;\n  let newContent: string;\n\n  if (instructions_override !== undefined || content_override !== undefined) {\n    // Manual override mode\n    newInstructions = instructions_override ?? currentInstructions;\n    newContent = content_override ?? currentContent;\n  } else {\n    // Auto-detection: field values stay the same — the managers already assigned the\n    // body text to the correct field during load (per getV1BodyMapping). The upgrade\n    // is the re-save itself: serializeElement() writes instructions to YAML frontmatter\n    // and content as the markdown body, converting the on-disk format from v1 to v2.\n    newInstructions = currentInstructions;\n    newContent = currentContent;\n  }\n\n  if (dry_run) {\n    // Preview mode — show what would change\n    const changes: string[] = [];\n    if (newInstructions !== currentInstructions) {\n      changes.push(`**instructions**: \"${truncate(currentInstructions, 80)}\" → \"${truncate(newInstructions, 80)}\"`);\n    }\n    if (newContent !== currentContent) {\n      changes.push(`**content**: \"${truncate(currentContent, 80)}\" → \"${truncate(newContent, 80)}\"`);\n    }\n\n    const displayName = (element as any).metadata?.name || name;\n    const label = getElementTypeLabel(normalizedType);\n\n    if (changes.length === 0) {\n      return {\n        content: [{\n          type: 'text',\n          text: `ℹ️ ${label} '${displayName}' — no field changes needed for upgrade.\\n\\n` +\n            `The file will be re-saved in v2 format (instructions in YAML frontmatter, content as body).\\n\\n` +\n            `**instructions** (${newInstructions.length} chars): ${truncate(newInstructions, 150)}\\n` +\n            `**content** (${newContent.length} chars): ${truncate(newContent, 150)}`\n        }]\n      };\n    }\n\n    return {\n      content: [{\n        type: 'text',\n        text: `🔍 Dry run — ${label} '${displayName}' upgrade preview:\\n\\n` +\n          changes.join('\\n') + '\\n\\n' +\n          `Run without dry_run to apply these changes.`\n      }]\n    };\n  }\n\n  // Apply upgrade\n  (element as any).instructions = newInstructions;\n  // For Memory, content is a getter — skip direct assignment\n  if (normalizedType !== ElementType.MEMORY) {\n    (element as any).content = newContent;\n  }\n\n  // Determine file path for saving\n  const filePathCandidate = typeof (element as any).getFilePath === 'function'\n    ? (element as any).getFilePath()\n    : ((element as any).filePath || (element as any).filename);\n  const filename = typeof filePathCandidate === 'string' && filePathCandidate.length > 0\n    ? filePathCandidate\n    : '';\n\n  if (!filename) {\n    return error(`Cannot determine file path for ${getElementTypeLabel(normalizedType)} '${name}'`);\n  }\n\n  try {\n    await manager.save(element, filename);\n  } catch (err) {\n    return error(`Failed to save upgraded element: ${err instanceof Error ? err.message : 'Unknown error'}`);\n  }\n\n  const displayName = (element as any).metadata?.name || name;\n  const label = getElementTypeLabel(normalizedType);\n\n  logger.info(`[upgradeElement] Upgraded ${label} '${displayName}' to v2 dual-field format`, {\n    elementType: normalizedType,\n    elementName: displayName,\n    instructionsLength: newInstructions.length,\n    contentLength: newContent.length,\n  });\n\n  return {\n    content: [{\n      type: 'text',\n      text: `✅ Upgraded ${label} '${displayName}' to v2 dual-field format.\\n\\n` +\n        `**instructions** (${newInstructions.length} chars): ${truncate(newInstructions, 150)}\\n` +\n        `**content** (${newContent.length} chars): ${truncate(newContent, 150)}`\n    }]\n  };\n}\n\nfunction error(message: string) {\n  return {\n    content: [{\n      type: 'text',\n      text: `❌ ${message}`\n    }]\n  };\n}\n\nfunction truncate(text: string, maxLength: number): string {\n  if (!text) return '(empty)';\n  if (text.length <= maxLength) return text;\n  return text.slice(0, maxLength) + '...';\n}\n\nfunction getManagerForType(context: ElementCrudContext, type: ElementType): ElementManagerWithPersistence<any> | null {\n  switch (type) {\n    case ElementType.PERSONA:\n      return context.personaManager as ElementManagerWithPersistence<any>;\n    case ElementType.SKILL:\n      return context.skillManager as ElementManagerWithPersistence<any>;\n    case ElementType.TEMPLATE:\n      return context.templateManager as ElementManagerWithPersistence<any>;\n    case ElementType.AGENT:\n      return context.agentManager as ElementManagerWithPersistence<any>;\n    case ElementType.MEMORY:\n      return context.memoryManager as ElementManagerWithPersistence<any>;\n    case ElementType.ENSEMBLE:\n      return context.ensembleManager as ElementManagerWithPersistence<any>;\n    default:\n      return null;\n  }\n}\n"]}