@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.
386 lines • 45.1 kB
JavaScript
/**
* MetadataService - Centralized metadata normalization and defaults
*
* Eliminates ~300 LOC of duplicate metadata handling across 6 element managers.
*
* Key Features:
* - Consistent metadata structure across all element types
* - Automatic default value assignment
* - Version normalization (1.0 → 1.0.0)
* - Unique ID generation
* - User attribution with fallback chain
* - Date formatting (ISO 8601)
*
* Architecture:
* - Pure service (no state except currentUser)
* - Type-safe with TypeScript strict mode
* - Security-first (validates all inputs)
* - Preserves exact current behavior from managers
*
* @example
* ```typescript
* const metadata = metadataService.normalizeMetadata(
* { name: 'My Skill', description: 'Does things' },
* ElementType.SKILL
* );
* // Returns: { name: 'My Skill', description: 'Does things',
* // version: '1.0.0', author: 'user', created: '2025-11-19', ... }
* ```
*/
import { userInfo } from 'node:os';
import { ElementType } from '../portfolio/types.js';
import { toSingularLabel } from '../utils/elementTypeNormalization.js';
import { generateAnonymousId, generateUniqueId } from '../utils/filesystem.js';
import { normalizeVersion } from '../elements/BaseElement.js';
import { logger } from '../utils/logger.js';
/**
* MetadataService - Centralized metadata normalization and defaults
*
* ZERO FUNCTIONALITY LOSS:
* This service extracts exact behavior from all 6 managers without any changes.
* Every default value, every normalization rule, every edge case is preserved.
*
* USAGE:
* ```typescript
* const metadata = metadataService.normalizeMetadata(
* rawMetadata,
* ElementType.SKILL,
* {
* typeDefaults: {
* category: 'general',
* difficulty: 'intermediate'
* }
* }
* );
* ```
*/
export class MetadataService {
currentUser = null;
/**
* Normalize metadata with type-specific defaults
*
* Applies:
* - Default values for missing fields
* - Version normalization (1.0 → 1.0.0)
* - Unique ID generation
* - User attribution
* - Date formatting (ISO 8601)
*
* PRESERVES EXACT BEHAVIOR:
* - PersonaManager: lines 164-205 (normalizePersonaForSave)
* - AgentManager: lines 113, 642-644 (getCurrentUserForAttribution)
* - MemoryManager: lines 1342-1421 (parseMemoryFile metadata defaults)
* - SkillManager: lines 44-102 (create method defaults)
* - TemplateManager: lines 298-375 (validateMetadata defaults)
* - EnsembleManager: lines 86-347 (parseMetadata defaults)
*
* @param raw - Raw metadata from user input or file
* @param elementType - Type of element being created
* @param options - Normalization options
* @returns Fully normalized metadata
*
* @example
* const metadata = metadataService.normalizeMetadata(
* { name: 'My Skill', description: 'Does things' },
* ElementType.SKILL
* );
* // Returns: { name: 'My Skill', description: 'Does things',
* // version: '1.0.0', author: 'user', created: '2025-11-19', ... }
*/
normalizeMetadata(raw, elementType, options = {}) {
// Set default options
const opts = {
preserveExisting: options.preserveExisting ?? false,
generateId: options.generateId ?? true,
normalizeVersion: options.normalizeVersion ?? true,
setAuthor: options.setAuthor ?? true,
setCreated: options.setCreated ?? true,
setModified: options.setModified ?? true,
typeDefaults: options.typeDefaults ?? {},
skipTypeDefaults: options.skipTypeDefaults ?? false
};
// Start with raw metadata
const normalized = { ...raw };
// Apply type-specific defaults FIRST (can be overridden by standard defaults)
// Skip if skipTypeDefaults is true (for BaseElement constructor)
if (opts.typeDefaults && Object.keys(opts.typeDefaults).length > 0 && !opts.skipTypeDefaults) {
for (const [key, value] of Object.entries(opts.typeDefaults)) {
if (normalized[key] === undefined || (opts.preserveExisting === false && !normalized[key])) {
normalized[key] = value;
}
}
}
// Apply standard metadata defaults
// Name (required field, should already be set, but ensure it exists)
if (!normalized.name) {
normalized.name = `Untitled ${this.getElementTypeName(elementType)}`;
}
// Description
if (normalized.description === undefined || normalized.description === null) {
normalized.description = '';
}
// Version normalization
if (opts.normalizeVersion) {
if (!normalized.version) {
normalized.version = '1.0.0';
}
else {
normalized.version = this.normalizeVersion(String(normalized.version));
}
}
// Author attribution
if (opts.setAuthor && !normalized.author) {
normalized.author = this.getCurrentUser();
}
// Created date (YYYY-MM-DD format, matching PersonaManager line 178)
if (opts.setCreated && !normalized.created) {
if (normalized.created_date) {
normalized.created = String(normalized.created_date).split('T')[0];
}
else {
normalized.created = this.generateDate('date-only');
}
}
// Modified date (ISO 8601 full format, matching AgentManager line 231)
if (opts.setModified && !normalized.modified) {
normalized.modified = this.generateDate('full');
}
// Tags (initialize empty array if not provided)
if (!normalized.tags) {
normalized.tags = [];
}
// Unique ID generation (if enabled and missing)
if (opts.generateId && !normalized.unique_id) {
const author = normalized.author || this.getCurrentUser();
normalized.unique_id = this.assignUniqueId(normalized.name, author);
}
// Set element type if not present
if (!normalized.type) {
normalized.type = elementType;
}
return normalized;
}
/**
* Generate default metadata for an element type
*
* Provides baseline metadata structure with all required fields populated.
* Useful for creating new elements or testing.
*
* @param elementType - Type of element
* @param overrides - Optional field overrides
* @returns Default metadata structure
*
* @example
* const defaults = metadataService.generateDefaultMetadata(ElementType.SKILL);
* // Returns: { name: 'Untitled Skill', description: '',
* // version: '1.0.0', author: 'anonymous', ... }
*/
generateDefaultMetadata(elementType, overrides = {}) {
const defaults = {
name: `Untitled ${this.getElementTypeName(elementType)}`,
description: '',
version: '1.0.0',
author: this.getCurrentUser(),
created: this.generateDate('date-only'),
modified: this.generateDate('full'),
type: elementType
};
return { ...defaults, ...overrides };
}
/**
* Assign a unique ID based on name and author
*
* Format: Uses existing generateUniqueId utility which creates:
* `{slugified-name}-{author-hash}` or random UUID
*
* PRESERVES EXACT BEHAVIOR:
* - PersonaManager line 181-182: generateUniqueId(metadata.name, metadata.author)
* - PersonaManager line 567: generateUniqueId(sanitizedName, this.getCurrentUserForAttribution() || undefined)
*
* @param name - Element name
* @param author - Element author
* @returns Unique identifier string
*
* @example
* const id = metadataService.assignUniqueId('My Skill', 'john');
* // Returns: 'my-skill-a3f8d9e2' (or similar hash)
*/
assignUniqueId(name, author) {
// Use existing utility function (preserves exact behavior)
return generateUniqueId(name, author);
}
/**
* Get current user for attribution
*
* Priority:
* 1. Service-level currentUser (set via setCurrentUser)
* 2. Environment variable DOLLHOUSE_USER
* 3. OS system username (os.userInfo().username)
* 4. Anonymous ID generation (last resort)
*
* The result is cached on first resolution so subsequent calls
* return the same value without re-resolving.
*
* @returns Username or anonymous ID
*/
getCurrentUser() {
if (!this.currentUser) {
const envUser = process.env.DOLLHOUSE_USER;
if (envUser) {
this.currentUser = envUser;
logger.debug('[MetadataService] User resolved from DOLLHOUSE_USER env var', { user: envUser });
}
else {
let osUser = null;
try {
osUser = userInfo().username || null;
}
catch { /* platform unsupported */ }
if (osUser) {
this.currentUser = osUser;
logger.debug('[MetadataService] User resolved from OS username', { user: osUser });
}
else {
this.currentUser = generateAnonymousId();
logger.debug('[MetadataService] User resolved as anonymous (no env var or OS username available)', { user: this.currentUser });
}
}
}
return this.currentUser;
}
/**
* Set current user identity
*
* @param username - Username to set (null to clear)
*
* @example
* metadataService.setCurrentUser('john');
* metadataService.setCurrentUser(null); // Clear
*/
setCurrentUser(username) {
this.currentUser = username;
logger.debug('[MetadataService] Current user set', { username });
}
/**
* Normalize version string to semantic versioning format
*
* Handles:
* - 1.0 → 1.0.0
* - 2 → 2.0.0
* - 1.2.3-beta → 1.2.3-beta (preserves pre-release)
*
* PRESERVES EXACT BEHAVIOR:
* - PersonaManager line 173: metadata.version = normalizeVersion(metadata.version)
* - PersonaManager line 786-787: normalizeVersion(String(editablePersona.version))
* - Uses existing normalizeVersion() utility from BaseElement
*
* @param version - Version string to normalize
* @returns Normalized version string
*
* @example
* const v = metadataService.normalizeVersion('1.0');
* // Returns: '1.0.0'
*/
normalizeVersion(version) {
// Use existing utility function (preserves exact behavior)
return normalizeVersion(version);
}
/**
* Generate ISO 8601 date string
*
* PRESERVES EXACT BEHAVIOR:
* - PersonaManager line 178: new Date().toISOString().split('T')[0] (date-only)
* - AgentManager line 231: new Date().toISOString() (full)
*
* @param format - Date format ('full' or 'date-only')
* @returns Formatted date string
*
* @example
* const date = metadataService.generateDate('date-only');
* // Returns: '2025-11-19'
*
* const datetime = metadataService.generateDate('full');
* // Returns: '2025-11-19T10:30:45.123Z'
*/
generateDate(format = 'full') {
const now = new Date().toISOString();
if (format === 'date-only') {
// Match PersonaManager line 178 exactly
return now.split('T')[0];
}
// Full ISO 8601 format
return now;
}
/**
* Validate metadata completeness
*
* Checks:
* - Required fields present (name, description)
* - Valid types for all fields
* - Value constraints (version format, etc.)
*
* @param metadata - Metadata to validate
* @param elementType - Element type for type-specific validation
* @returns Validation result
*
* @example
* const result = metadataService.validateMetadata(metadata, ElementType.SKILL);
* if (!result.valid) {
* console.error('Validation errors:', result.errors);
* }
*/
validateMetadata(metadata, elementType) {
const errors = [];
// Required fields
if (!metadata.name || typeof metadata.name !== 'string' || metadata.name.trim().length === 0) {
errors.push('name is required and must be a non-empty string');
}
if (metadata.description === undefined || metadata.description === null) {
errors.push('description is required (can be empty string)');
}
if (!metadata.version || typeof metadata.version !== 'string') {
errors.push('version is required and must be a string');
}
// Type validation
if (metadata.author !== undefined && typeof metadata.author !== 'string') {
errors.push('author must be a string');
}
if (metadata.created !== undefined && typeof metadata.created !== 'string') {
errors.push('created must be a date string');
}
if (metadata.modified !== undefined && typeof metadata.modified !== 'string') {
errors.push('modified must be a date string');
}
if (metadata.tags !== undefined && !Array.isArray(metadata.tags)) {
errors.push('tags must be an array');
}
if (metadata.triggers !== undefined && !Array.isArray(metadata.triggers)) {
errors.push('triggers must be an array');
}
// Issue #755: Accept both plural ElementType ('agents') and singular label ('agent')
if (metadata.type !== undefined && metadata.type !== elementType && metadata.type !== toSingularLabel(elementType)) {
errors.push(`type must match element type (expected: ${elementType}, got: ${metadata.type})`);
}
return {
valid: errors.length === 0,
errors: errors.length > 0 ? errors : undefined
};
}
// Private helper methods
/**
* Get human-readable element type name
* @private
*/
getElementTypeName(elementType) {
const typeNames = {
[ElementType.SKILL]: 'Skill',
[ElementType.PERSONA]: 'Persona',
[ElementType.TEMPLATE]: 'Template',
[ElementType.AGENT]: 'Agent',
[ElementType.MEMORY]: 'Memory',
[ElementType.ENSEMBLE]: 'Ensemble'
};
return typeNames[elementType] || 'Element';
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MetadataService.js","sourceRoot":"","sources":["../../src/services/MetadataService.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * MetadataService - Centralized metadata normalization and defaults\n *\n * Eliminates ~300 LOC of duplicate metadata handling across 6 element managers.\n *\n * Key Features:\n * - Consistent metadata structure across all element types\n * - Automatic default value assignment\n * - Version normalization (1.0 → 1.0.0)\n * - Unique ID generation\n * - User attribution with fallback chain\n * - Date formatting (ISO 8601)\n *\n * Architecture:\n * - Pure service (no state except currentUser)\n * - Type-safe with TypeScript strict mode\n * - Security-first (validates all inputs)\n * - Preserves exact current behavior from managers\n *\n * @example\n * ```typescript\n * const metadata = metadataService.normalizeMetadata(\n *   { name: 'My Skill', description: 'Does things' },\n *   ElementType.SKILL\n * );\n * // Returns: { name: 'My Skill', description: 'Does things',\n * //           version: '1.0.0', author: 'user', created: '2025-11-19', ... }\n * ```\n */\n\nimport { userInfo } from 'node:os';\nimport { ElementType } from '../portfolio/types.js';\nimport { toSingularLabel } from '../utils/elementTypeNormalization.js';\nimport { generateAnonymousId, generateUniqueId } from '../utils/filesystem.js';\nimport { normalizeVersion } from '../elements/BaseElement.js';\nimport { logger } from '../utils/logger.js';\n\n/**\n * Base metadata interface (common to all elements)\n */\nexport interface BaseMetadata {\n  name: string;\n  description: string;\n  version?: string;  // Made optional - normalizeMetadata will set default '1.0.0'\n  author?: string;\n  created?: string;\n  modified?: string;\n  tags?: string[];\n  triggers?: string[];\n  unique_id?: string;\n  type?: ElementType;\n}\n\n/**\n * Options for metadata normalization\n */\nexport interface MetadataNormalizationOptions {\n  /** Whether to preserve existing values instead of applying defaults (default: false) */\n  preserveExisting?: boolean;\n\n  /** Whether to generate unique ID if missing (default: true) */\n  generateId?: boolean;\n\n  /** Whether to normalize version format (default: true) */\n  normalizeVersion?: boolean;\n\n  /** Whether to set current user as author (default: true) */\n  setAuthor?: boolean;\n\n  /** Whether to set creation date if missing (default: true) */\n  setCreated?: boolean;\n\n  /** Whether to set modified date (default: true) */\n  setModified?: boolean;\n\n  /** Additional type-specific defaults to merge */\n  typeDefaults?: Record<string, any>;\n\n  /** Skip applying typeDefaults (for BaseElement constructor) - only normalize common fields */\n  skipTypeDefaults?: boolean;\n}\n\n/**\n * MetadataService - Centralized metadata normalization and defaults\n *\n * ZERO FUNCTIONALITY LOSS:\n * This service extracts exact behavior from all 6 managers without any changes.\n * Every default value, every normalization rule, every edge case is preserved.\n *\n * USAGE:\n * ```typescript\n * const metadata = metadataService.normalizeMetadata(\n *   rawMetadata,\n *   ElementType.SKILL,\n *   {\n *     typeDefaults: {\n *       category: 'general',\n *       difficulty: 'intermediate'\n *     }\n *   }\n * );\n * ```\n */\nexport class MetadataService {\n  private currentUser: string | null = null;\n\n  /**\n   * Normalize metadata with type-specific defaults\n   *\n   * Applies:\n   * - Default values for missing fields\n   * - Version normalization (1.0 → 1.0.0)\n   * - Unique ID generation\n   * - User attribution\n   * - Date formatting (ISO 8601)\n   *\n   * PRESERVES EXACT BEHAVIOR:\n   * - PersonaManager: lines 164-205 (normalizePersonaForSave)\n   * - AgentManager: lines 113, 642-644 (getCurrentUserForAttribution)\n   * - MemoryManager: lines 1342-1421 (parseMemoryFile metadata defaults)\n   * - SkillManager: lines 44-102 (create method defaults)\n   * - TemplateManager: lines 298-375 (validateMetadata defaults)\n   * - EnsembleManager: lines 86-347 (parseMetadata defaults)\n   *\n   * @param raw - Raw metadata from user input or file\n   * @param elementType - Type of element being created\n   * @param options - Normalization options\n   * @returns Fully normalized metadata\n   *\n   * @example\n   * const metadata = metadataService.normalizeMetadata(\n   *   { name: 'My Skill', description: 'Does things' },\n   *   ElementType.SKILL\n   * );\n   * // Returns: { name: 'My Skill', description: 'Does things',\n   * //           version: '1.0.0', author: 'user', created: '2025-11-19', ... }\n   */\n  normalizeMetadata<T extends BaseMetadata>(\n    raw: Partial<T>,\n    elementType: ElementType,\n    options: MetadataNormalizationOptions = {}\n  ): T {\n    // Set default options\n    const opts = {\n      preserveExisting: options.preserveExisting ?? false,\n      generateId: options.generateId ?? true,\n      normalizeVersion: options.normalizeVersion ?? true,\n      setAuthor: options.setAuthor ?? true,\n      setCreated: options.setCreated ?? true,\n      setModified: options.setModified ?? true,\n      typeDefaults: options.typeDefaults ?? {},\n      skipTypeDefaults: options.skipTypeDefaults ?? false\n    };\n\n    // Start with raw metadata\n    const normalized: any = { ...raw };\n\n    // Apply type-specific defaults FIRST (can be overridden by standard defaults)\n    // Skip if skipTypeDefaults is true (for BaseElement constructor)\n    if (opts.typeDefaults && Object.keys(opts.typeDefaults).length > 0 && !opts.skipTypeDefaults) {\n      for (const [key, value] of Object.entries(opts.typeDefaults)) {\n        if (normalized[key] === undefined || (opts.preserveExisting === false && !normalized[key])) {\n          normalized[key] = value;\n        }\n      }\n    }\n\n    // Apply standard metadata defaults\n\n    // Name (required field, should already be set, but ensure it exists)\n    if (!normalized.name) {\n      normalized.name = `Untitled ${this.getElementTypeName(elementType)}`;\n    }\n\n    // Description\n    if (normalized.description === undefined || normalized.description === null) {\n      normalized.description = '';\n    }\n\n    // Version normalization\n    if (opts.normalizeVersion) {\n      if (!normalized.version) {\n        normalized.version = '1.0.0';\n      } else {\n        normalized.version = this.normalizeVersion(String(normalized.version));\n      }\n    }\n\n    // Author attribution\n    if (opts.setAuthor && !normalized.author) {\n      normalized.author = this.getCurrentUser();\n    }\n\n    // Created date (YYYY-MM-DD format, matching PersonaManager line 178)\n    if (opts.setCreated && !normalized.created) {\n      if (normalized.created_date) {\n        normalized.created = String(normalized.created_date).split('T')[0];\n      } else {\n        normalized.created = this.generateDate('date-only');\n      }\n    }\n\n    // Modified date (ISO 8601 full format, matching AgentManager line 231)\n    if (opts.setModified && !normalized.modified) {\n      normalized.modified = this.generateDate('full');\n    }\n\n    // Tags (initialize empty array if not provided)\n    if (!normalized.tags) {\n      normalized.tags = [];\n    }\n\n    // Unique ID generation (if enabled and missing)\n    if (opts.generateId && !normalized.unique_id) {\n      const author = normalized.author || this.getCurrentUser();\n      normalized.unique_id = this.assignUniqueId(normalized.name, author);\n    }\n\n    // Set element type if not present\n    if (!normalized.type) {\n      normalized.type = elementType;\n    }\n\n    return normalized as T;\n  }\n\n  /**\n   * Generate default metadata for an element type\n   *\n   * Provides baseline metadata structure with all required fields populated.\n   * Useful for creating new elements or testing.\n   *\n   * @param elementType - Type of element\n   * @param overrides - Optional field overrides\n   * @returns Default metadata structure\n   *\n   * @example\n   * const defaults = metadataService.generateDefaultMetadata(ElementType.SKILL);\n   * // Returns: { name: 'Untitled Skill', description: '',\n   * //           version: '1.0.0', author: 'anonymous', ... }\n   */\n  generateDefaultMetadata(\n    elementType: ElementType,\n    overrides: Partial<BaseMetadata> = {}\n  ): BaseMetadata {\n    const defaults: BaseMetadata = {\n      name: `Untitled ${this.getElementTypeName(elementType)}`,\n      description: '',\n      version: '1.0.0',\n      author: this.getCurrentUser(),\n      created: this.generateDate('date-only'),\n      modified: this.generateDate('full'),\n      type: elementType\n    };\n\n    return { ...defaults, ...overrides };\n  }\n\n  /**\n   * Assign a unique ID based on name and author\n   *\n   * Format: Uses existing generateUniqueId utility which creates:\n   * `{slugified-name}-{author-hash}` or random UUID\n   *\n   * PRESERVES EXACT BEHAVIOR:\n   * - PersonaManager line 181-182: generateUniqueId(metadata.name, metadata.author)\n   * - PersonaManager line 567: generateUniqueId(sanitizedName, this.getCurrentUserForAttribution() || undefined)\n   *\n   * @param name - Element name\n   * @param author - Element author\n   * @returns Unique identifier string\n   *\n   * @example\n   * const id = metadataService.assignUniqueId('My Skill', 'john');\n   * // Returns: 'my-skill-a3f8d9e2' (or similar hash)\n   */\n  assignUniqueId(name: string, author: string): string {\n    // Use existing utility function (preserves exact behavior)\n    return generateUniqueId(name, author);\n  }\n\n  /**\n   * Get current user for attribution\n   *\n   * Priority:\n   * 1. Service-level currentUser (set via setCurrentUser)\n   * 2. Environment variable DOLLHOUSE_USER\n   * 3. OS system username (os.userInfo().username)\n   * 4. Anonymous ID generation (last resort)\n   *\n   * The result is cached on first resolution so subsequent calls\n   * return the same value without re-resolving.\n   *\n   * @returns Username or anonymous ID\n   */\n  getCurrentUser(): string {\n    if (!this.currentUser) {\n      const envUser = process.env.DOLLHOUSE_USER;\n      if (envUser) {\n        this.currentUser = envUser;\n        logger.debug('[MetadataService] User resolved from DOLLHOUSE_USER env var', { user: envUser });\n      } else {\n        let osUser: string | null = null;\n        try { osUser = userInfo().username || null; } catch { /* platform unsupported */ }\n        if (osUser) {\n          this.currentUser = osUser;\n          logger.debug('[MetadataService] User resolved from OS username', { user: osUser });\n        } else {\n          this.currentUser = generateAnonymousId();\n          logger.debug('[MetadataService] User resolved as anonymous (no env var or OS username available)', { user: this.currentUser });\n        }\n      }\n    }\n    return this.currentUser;\n  }\n\n  /**\n   * Set current user identity\n   *\n   * @param username - Username to set (null to clear)\n   *\n   * @example\n   * metadataService.setCurrentUser('john');\n   * metadataService.setCurrentUser(null); // Clear\n   */\n  setCurrentUser(username: string | null): void {\n    this.currentUser = username;\n    logger.debug('[MetadataService] Current user set', { username });\n  }\n\n  /**\n   * Normalize version string to semantic versioning format\n   *\n   * Handles:\n   * - 1.0 → 1.0.0\n   * - 2 → 2.0.0\n   * - 1.2.3-beta → 1.2.3-beta (preserves pre-release)\n   *\n   * PRESERVES EXACT BEHAVIOR:\n   * - PersonaManager line 173: metadata.version = normalizeVersion(metadata.version)\n   * - PersonaManager line 786-787: normalizeVersion(String(editablePersona.version))\n   * - Uses existing normalizeVersion() utility from BaseElement\n   *\n   * @param version - Version string to normalize\n   * @returns Normalized version string\n   *\n   * @example\n   * const v = metadataService.normalizeVersion('1.0');\n   * // Returns: '1.0.0'\n   */\n  normalizeVersion(version: string): string {\n    // Use existing utility function (preserves exact behavior)\n    return normalizeVersion(version);\n  }\n\n  /**\n   * Generate ISO 8601 date string\n   *\n   * PRESERVES EXACT BEHAVIOR:\n   * - PersonaManager line 178: new Date().toISOString().split('T')[0] (date-only)\n   * - AgentManager line 231: new Date().toISOString() (full)\n   *\n   * @param format - Date format ('full' or 'date-only')\n   * @returns Formatted date string\n   *\n   * @example\n   * const date = metadataService.generateDate('date-only');\n   * // Returns: '2025-11-19'\n   *\n   * const datetime = metadataService.generateDate('full');\n   * // Returns: '2025-11-19T10:30:45.123Z'\n   */\n  generateDate(format: 'full' | 'date-only' = 'full'): string {\n    const now = new Date().toISOString();\n\n    if (format === 'date-only') {\n      // Match PersonaManager line 178 exactly\n      return now.split('T')[0];\n    }\n\n    // Full ISO 8601 format\n    return now;\n  }\n\n  /**\n   * Validate metadata completeness\n   *\n   * Checks:\n   * - Required fields present (name, description)\n   * - Valid types for all fields\n   * - Value constraints (version format, etc.)\n   *\n   * @param metadata - Metadata to validate\n   * @param elementType - Element type for type-specific validation\n   * @returns Validation result\n   *\n   * @example\n   * const result = metadataService.validateMetadata(metadata, ElementType.SKILL);\n   * if (!result.valid) {\n   *   console.error('Validation errors:', result.errors);\n   * }\n   */\n  validateMetadata(\n    metadata: BaseMetadata,\n    elementType: ElementType\n  ): { valid: boolean; errors?: string[] } {\n    const errors: string[] = [];\n\n    // Required fields\n    if (!metadata.name || typeof metadata.name !== 'string' || metadata.name.trim().length === 0) {\n      errors.push('name is required and must be a non-empty string');\n    }\n\n    if (metadata.description === undefined || metadata.description === null) {\n      errors.push('description is required (can be empty string)');\n    }\n\n    if (!metadata.version || typeof metadata.version !== 'string') {\n      errors.push('version is required and must be a string');\n    }\n\n    // Type validation\n    if (metadata.author !== undefined && typeof metadata.author !== 'string') {\n      errors.push('author must be a string');\n    }\n\n    if (metadata.created !== undefined && typeof metadata.created !== 'string') {\n      errors.push('created must be a date string');\n    }\n\n    if (metadata.modified !== undefined && typeof metadata.modified !== 'string') {\n      errors.push('modified must be a date string');\n    }\n\n    if (metadata.tags !== undefined && !Array.isArray(metadata.tags)) {\n      errors.push('tags must be an array');\n    }\n\n    if (metadata.triggers !== undefined && !Array.isArray(metadata.triggers)) {\n      errors.push('triggers must be an array');\n    }\n\n    // Issue #755: Accept both plural ElementType ('agents') and singular label ('agent')\n    if (metadata.type !== undefined && metadata.type !== elementType && metadata.type !== toSingularLabel(elementType)) {\n      errors.push(`type must match element type (expected: ${elementType}, got: ${metadata.type})`);\n    }\n\n    return {\n      valid: errors.length === 0,\n      errors: errors.length > 0 ? errors : undefined\n    };\n  }\n\n  // Private helper methods\n\n  /**\n   * Get human-readable element type name\n   * @private\n   */\n  private getElementTypeName(elementType: ElementType): string {\n    const typeNames: Record<ElementType, string> = {\n      [ElementType.SKILL]: 'Skill',\n      [ElementType.PERSONA]: 'Persona',\n      [ElementType.TEMPLATE]: 'Template',\n      [ElementType.AGENT]: 'Agent',\n      [ElementType.MEMORY]: 'Memory',\n      [ElementType.ENSEMBLE]: 'Ensemble'\n    };\n\n    return typeNames[elementType] || 'Element';\n  }\n}\n"]}