@dollhousemcp/mcp-server 1.3.0

package/dist/test/src/utils/filesystem.js

@@ -0,0 +1,94 @@
+/**
+ * Filesystem and string manipulation utilities
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { ADJECTIVES, ANIMALS } from '../config/constants.js';
+/**
+ * Generate an anonymous ID for users without identity
+ */
+export function generateAnonymousId() {
+    const adjective = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)];
+    const animal = ANIMALS[Math.floor(Math.random() * ANIMALS.length)];
+    const random = Math.random().toString(36).substring(2, 6);
+    return `anon-${adjective}-${animal}-${random}`;
+}
+/**
+ * Generate a unique ID for personas
+ */
+// Pre-compiled regex for better performance (avoids creating regex on each character)
+const ALPHANUMERIC_REGEX = /[a-z0-9]/;
+export function generateUniqueId(personaName, author) {
+    const now = new Date();
+    const dateStr = now.toISOString().slice(0, 10).replace(/-/g, '');
+    const timeStr = now.toTimeString().slice(0, 8).replace(/:/g, '');
+    // SECURITY FIX: Prevent ReDoS by using a single-pass approach
+    // Previously: Multiple replace() operations with unbounded quantifiers could cause exponential backtracking
+    // Now: Single-pass transformation with built-in length limit
+    const normalized = personaName.toLowerCase();
+    const sanitizedName = normalized
+        .split('')
+        .map(char => ALPHANUMERIC_REGEX.test(char) ? char : '-')
+        .join('')
+        .substring(0, 100) // Limit after transformation to preserve structure
+        .replace(/^-+|-+$/g, '') // Only trim leading/trailing hyphens
+        .replace(/-{2,}/g, '-'); // Collapse multiple hyphens
+    const whoMadeIt = author || generateAnonymousId();
+    return `${sanitizedName}_${dateStr}-${timeStr}_${whoMadeIt}`;
+}
+/**
+ * Convert text to URL-safe slug
+ */
+export function slugify(text) {
+    // SECURITY FIX: Prevent ReDoS by using a single-pass approach
+    // Previously: Multiple replace() operations with unbounded quantifiers could cause exponential backtracking
+    // Now: Single-pass transformation with built-in length limit
+    const normalized = text.toLowerCase();
+    return normalized
+        .split('')
+        .map(char => ALPHANUMERIC_REGEX.test(char) ? char : '-')
+        .join('')
+        .replace(/^-+|-+$/g, '') // Only trim leading/trailing hyphens
+        .replace(/-{2,}/g, '-'); // Collapse multiple hyphens
+}
+/**
+ * Ensure a directory exists, create if it doesn't
+ */
+export async function ensureDirectory(dirPath) {
+    try {
+        await fs.access(dirPath);
+    }
+    catch {
+        await fs.mkdir(dirPath, { recursive: true });
+    }
+}
+/**
+ * Check if a file exists
+ */
+export async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get file size in bytes
+ */
+export async function getFileSize(filePath) {
+    const stats = await fs.stat(filePath);
+    return stats.size;
+}
+/**
+ * Create a backup of a directory
+ */
+export async function createBackup(sourcePath, backupPath) {
+    // Ensure backup directory exists
+    const backupDir = path.dirname(backupPath);
+    await ensureDirectory(backupDir);
+    // Copy directory recursively
+    await fs.cp(sourcePath, backupPath, { recursive: true });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filesystem.js","sourceRoot":"","sources":["../../../../src/utils/filesystem.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Filesystem and string manipulation utilities\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { ADJECTIVES, ANIMALS } from '../config/constants.js';\n\n/**\n * Generate an anonymous ID for users without identity\n */\nexport function generateAnonymousId(): string {\n  const adjective = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)];\n  const animal = ANIMALS[Math.floor(Math.random() * ANIMALS.length)];\n  const random = Math.random().toString(36).substring(2, 6);\n  return `anon-${adjective}-${animal}-${random}`;\n}\n\n/**\n * Generate a unique ID for personas\n */\n// Pre-compiled regex for better performance (avoids creating regex on each character)\nconst ALPHANUMERIC_REGEX = /[a-z0-9]/;\n\nexport function generateUniqueId(personaName: string, author?: string): string {\n  const now = new Date();\n  const dateStr = now.toISOString().slice(0, 10).replace(/-/g, '');\n  const timeStr = now.toTimeString().slice(0, 8).replace(/:/g, '');\n  // SECURITY FIX: Prevent ReDoS by using a single-pass approach\n  // Previously: Multiple replace() operations with unbounded quantifiers could cause exponential backtracking\n  // Now: Single-pass transformation with built-in length limit\n  const normalized = personaName.toLowerCase();\n  const sanitizedName = normalized\n    .split('')\n    .map(char => ALPHANUMERIC_REGEX.test(char) ? char : '-')\n    .join('')\n    .substring(0, 100) // Limit after transformation to preserve structure\n    .replace(/^-+|-+$/g, '') // Only trim leading/trailing hyphens\n    .replace(/-{2,}/g, '-'); // Collapse multiple hyphens\n  const whoMadeIt = author || generateAnonymousId();\n  \n  return `${sanitizedName}_${dateStr}-${timeStr}_${whoMadeIt}`;\n}\n\n/**\n * Convert text to URL-safe slug\n */\nexport function slugify(text: string): string {\n  // SECURITY FIX: Prevent ReDoS by using a single-pass approach\n  // Previously: Multiple replace() operations with unbounded quantifiers could cause exponential backtracking\n  // Now: Single-pass transformation with built-in length limit\n  const normalized = text.toLowerCase();\n  return normalized\n    .split('')\n    .map(char => ALPHANUMERIC_REGEX.test(char) ? char : '-')\n    .join('')\n    .replace(/^-+|-+$/g, '') // Only trim leading/trailing hyphens\n    .replace(/-{2,}/g, '-'); // Collapse multiple hyphens\n}\n\n/**\n * Ensure a directory exists, create if it doesn't\n */\nexport async function ensureDirectory(dirPath: string): Promise<void> {\n  try {\n    await fs.access(dirPath);\n  } catch {\n    await fs.mkdir(dirPath, { recursive: true });\n  }\n}\n\n/**\n * Check if a file exists\n */\nexport async function fileExists(filePath: string): Promise<boolean> {\n  try {\n    await fs.access(filePath);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Get file size in bytes\n */\nexport async function getFileSize(filePath: string): Promise<number> {\n  const stats = await fs.stat(filePath);\n  return stats.size;\n}\n\n/**\n * Create a backup of a directory\n */\nexport async function createBackup(sourcePath: string, backupPath: string): Promise<void> {\n  // Ensure backup directory exists\n  const backupDir = path.dirname(backupPath);\n  await ensureDirectory(backupDir);\n  \n  // Copy directory recursively\n  await fs.cp(sourcePath, backupPath, { recursive: true });\n}"]}

package/dist/test/src/utils/git.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Git-related utility functions
+ */
+import * as child_process from 'child_process';
+declare const exec: typeof child_process.exec.__promisify__;
+/**
+ * Execute a command safely using CommandValidator
+ */
+export declare function safeExec(command: string, args: string[], options?: {
+    cwd?: string;
+    timeout?: number;
+}): Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+/**
+ * Execute a command using exec (use only for trusted input)
+ */
+export { exec };
+/**
+ * Get current git branch
+ */
+export declare function getCurrentGitBranch(cwd: string): Promise<string>;
+/**
+ * Get current git commit hash
+ */
+export declare function getCurrentGitCommit(cwd: string): Promise<string>;
+/**
+ * Check if git repository has uncommitted changes
+ */
+export declare function hasUncommittedChanges(cwd: string): Promise<boolean>;
+//# sourceMappingURL=git.d.ts.map

package/dist/test/src/utils/git.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../../../src/utils/git.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,aAAa,MAAM,eAAe,CAAC;AAI/C,QAAA,MAAM,IAAI,yCAAgC,CAAC;AAE3C;;GAEG;AACH,wBAAsB,QAAQ,CAC5B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GAC/C,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAa7C;AAED;;GAEG;AACH,OAAO,EAAE,IAAI,EAAE,CAAC;AAEhB;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAOtE;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAOtE;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOzE"}

package/dist/test/src/utils/git.js

@@ -0,0 +1,65 @@
+/**
+ * Git-related utility functions
+ */
+import * as child_process from 'child_process';
+import { promisify } from 'util';
+import { CommandValidator } from '../security/commandValidator.js';
+const exec = promisify(child_process.exec);
+/**
+ * Execute a command safely using CommandValidator
+ */
+export async function safeExec(command, args, options = {}) {
+    try {
+        const result = await CommandValidator.secureExec(command, args, {
+            cwd: options.cwd,
+            timeout: options.timeout || 30000
+        });
+        return { stdout: result, stderr: '' };
+    }
+    catch (error) {
+        // Convert to expected format with stderr
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(errorMessage);
+    }
+}
+/**
+ * Execute a command using exec (use only for trusted input)
+ */
+export { exec };
+/**
+ * Get current git branch
+ */
+export async function getCurrentGitBranch(cwd) {
+    try {
+        const { stdout } = await safeExec('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd });
+        return stdout.trim();
+    }
+    catch (error) {
+        throw new Error(`Failed to get current git branch: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Get current git commit hash
+ */
+export async function getCurrentGitCommit(cwd) {
+    try {
+        const { stdout } = await safeExec('git', ['rev-parse', 'HEAD'], { cwd });
+        return stdout.trim();
+    }
+    catch (error) {
+        throw new Error(`Failed to get current git commit: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Check if git repository has uncommitted changes
+ */
+export async function hasUncommittedChanges(cwd) {
+    try {
+        const { stdout } = await safeExec('git', ['status', '--porcelain'], { cwd });
+        return stdout.trim().length > 0;
+    }
+    catch (error) {
+        throw new Error(`Failed to check git status: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/src/utils/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Utilities module exports
+ */
+export * from './git.js';
+export * from './filesystem.js';
+export * from './version.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/test/src/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,UAAU,CAAC;AACzB,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC"}

package/dist/test/src/utils/index.js

@@ -0,0 +1,7 @@
+/**
+ * Utilities module exports
+ */
+export * from './git.js';
+export * from './filesystem.js';
+export * from './version.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBVdGlsaXRpZXMgbW9kdWxlIGV4cG9ydHNcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2dpdC5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2ZpbGVzeXN0ZW0uanMnO1xuZXhwb3J0ICogZnJvbSAnLi92ZXJzaW9uLmpzJzsiXX0=

package/dist/test/src/utils/logger.d.ts

@@ -0,0 +1,45 @@
+/**
+ * MCP-safe logger that avoids writing to stdout/stderr during protocol communication
+ *
+ * In MCP servers, stdout and stderr are reserved for JSON-RPC protocol messages.
+ * Any non-protocol output will cause "Unexpected token" errors in the MCP client.
+ *
+ * This logger:
+ * - Writes to stderr ONLY during server initialization (before MCP connection)
+ * - Stores all logs in memory during runtime
+ * - Provides methods to retrieve logs via MCP tools if needed
+ */
+interface LogEntry {
+    timestamp: Date;
+    level: 'debug' | 'info' | 'warn' | 'error';
+    message: string;
+    data?: any;
+}
+declare class MCPLogger {
+    private logs;
+    private maxLogs;
+    private isMCPConnected;
+    /**
+     * Call this after MCP connection is established to stop console output
+     */
+    setMCPConnected(): void;
+    /**
+     * Internal logging method
+     */
+    private log;
+    debug(message: string, data?: any): void;
+    info(message: string, data?: any): void;
+    warn(message: string, data?: any): void;
+    error(message: string, data?: any): void;
+    /**
+     * Get recent logs (for MCP tools to retrieve)
+     */
+    getLogs(count?: number, level?: LogEntry['level']): LogEntry[];
+    /**
+     * Clear logs
+     */
+    clearLogs(): void;
+}
+export declare const logger: MCPLogger;
+export {};
+//# sourceMappingURL=logger.d.ts.map

package/dist/test/src/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../../src/utils/logger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,UAAU,QAAQ;IAChB,SAAS,EAAE,IAAI,CAAC;IAChB,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;AAED,cAAM,SAAS;IACb,OAAO,CAAC,IAAI,CAAkB;IAC9B,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,cAAc,CAAS;IAE/B;;OAEG;IACI,eAAe,IAAI,IAAI;IAI9B;;OAEG;IACH,OAAO,CAAC,GAAG;IAqCJ,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;IAIxC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;IAIvC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;IAIvC,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;IAI/C;;OAEG;IACI,OAAO,CAAC,KAAK,SAAM,EAAE,KAAK,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,QAAQ,EAAE;IAQlE;;OAEG;IACI,SAAS,IAAI,IAAI;CAGzB;AAGD,eAAO,MAAM,MAAM,WAAkB,CAAC"}

package/dist/test/src/utils/logger.js

@@ -0,0 +1,91 @@
+/**
+ * MCP-safe logger that avoids writing to stdout/stderr during protocol communication
+ *
+ * In MCP servers, stdout and stderr are reserved for JSON-RPC protocol messages.
+ * Any non-protocol output will cause "Unexpected token" errors in the MCP client.
+ *
+ * This logger:
+ * - Writes to stderr ONLY during server initialization (before MCP connection)
+ * - Stores all logs in memory during runtime
+ * - Provides methods to retrieve logs via MCP tools if needed
+ */
+class MCPLogger {
+    logs = [];
+    maxLogs = 1000;
+    isMCPConnected = false;
+    /**
+     * Call this after MCP connection is established to stop console output
+     */
+    setMCPConnected() {
+        this.isMCPConnected = true;
+    }
+    /**
+     * Internal logging method
+     */
+    log(level, message, data) {
+        const entry = {
+            timestamp: new Date(),
+            level,
+            message,
+            data
+        };
+        // Store in memory
+        this.logs.push(entry);
+        if (this.logs.length > this.maxLogs) {
+            this.logs.shift();
+        }
+        // Only write to console during initialization
+        if (!this.isMCPConnected) {
+            // Check NODE_ENV inside the method to ensure it's evaluated at runtime
+            const isTest = process.env.NODE_ENV === 'test';
+            if (!isTest) {
+                const prefix = `[${entry.timestamp.toISOString()}] [${level.toUpperCase()}]`;
+                const fullMessage = data
+                    ? `${prefix} ${message} ${JSON.stringify(data)}`
+                    : `${prefix} ${message}`;
+                // During initialization, we can use console
+                if (level === 'error') {
+                    console.error(fullMessage);
+                }
+                else if (level === 'warn') {
+                    console.warn(fullMessage);
+                }
+                else {
+                    // For MCP, even during init, avoid stdout for info/debug
+                    console.error(fullMessage);
+                }
+            }
+        }
+    }
+    debug(message, data) {
+        this.log('debug', message, data);
+    }
+    info(message, data) {
+        this.log('info', message, data);
+    }
+    warn(message, data) {
+        this.log('warn', message, data);
+    }
+    error(message, data) {
+        this.log('error', message, data);
+    }
+    /**
+     * Get recent logs (for MCP tools to retrieve)
+     */
+    getLogs(count = 100, level) {
+        let filtered = this.logs;
+        if (level) {
+            filtered = this.logs.filter(log => log.level === level);
+        }
+        return filtered.slice(-count);
+    }
+    /**
+     * Clear logs
+     */
+    clearLogs() {
+        this.logs = [];
+    }
+}
+// Singleton instance
+export const logger = new MCPLogger();
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/src/utils/version.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Version comparison and parsing utilities
+ */
+/**
+ * Compare two semantic versions
+ * @returns -1 if version1 < version2, 0 if equal, 1 if version1 > version2
+ */
+export declare function compareVersions(version1: string, version2: string): number;
+/**
+ * Parse version from command output
+ */
+export declare function parseVersionFromOutput(output: string, tool: string): string | null;
+/**
+ * Validate dependency version against requirements
+ */
+export declare function validateDependencyVersion(actualVersion: string, requirements: {
+    minimum: string;
+    maximum: string;
+    recommended: string;
+}, toolName: string): {
+    valid: boolean;
+    warning?: string;
+    error?: string;
+};
+//# sourceMappingURL=version.d.ts.map

package/dist/test/src/utils/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../../src/utils/version.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CA8B1E;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAyBlF;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,EACvE,QAAQ,EAAE,MAAM,GACf;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CA8BtD"}

package/dist/test/src/utils/version.js

@@ -0,0 +1,97 @@
+/**
+ * Version comparison and parsing utilities
+ */
+/**
+ * Compare two semantic versions
+ * @returns -1 if version1 < version2, 0 if equal, 1 if version1 > version2
+ */
+export function compareVersions(version1, version2) {
+    // Normalize versions by removing 'v' prefix
+    const v1 = version1.replace(/^v/, '');
+    const v2 = version2.replace(/^v/, '');
+    // Split version and pre-release parts
+    const [v1main, v1pre] = v1.split('-');
+    const [v2main, v2pre] = v2.split('-');
+    // Compare main version parts (x.y.z)
+    const v1parts = v1main.split('.').map(part => parseInt(part) || 0);
+    const v2parts = v2main.split('.').map(part => parseInt(part) || 0);
+    const maxLength = Math.max(v1parts.length, v2parts.length);
+    for (let i = 0; i < maxLength; i++) {
+        const v1part = v1parts[i] || 0;
+        const v2part = v2parts[i] || 0;
+        if (v1part < v2part)
+            return -1;
+        if (v1part > v2part)
+            return 1;
+    }
+    // If main versions are equal, compare pre-release versions
+    // Version without pre-release is greater than version with pre-release
+    if (!v1pre && v2pre)
+        return 1; // 1.0.0 > 1.0.0-beta
+    if (v1pre && !v2pre)
+        return -1; // 1.0.0-beta < 1.0.0
+    if (!v1pre && !v2pre)
+        return 0; // 1.0.0 == 1.0.0
+    // Both have pre-release, compare lexicographically
+    return v1pre.localeCompare(v2pre);
+}
+/**
+ * Parse version from command output
+ */
+export function parseVersionFromOutput(output, tool) {
+    // Git version output: "git version 2.39.2"
+    // npm version output: "8.19.2" or JSON with version info
+    if (tool === 'git') {
+        const match = output.match(/git version (\d+\.\d+\.\d+)/);
+        return match ? match[1] : null;
+    }
+    else if (tool === 'npm') {
+        // npm might return just the version number or JSON
+        const cleanOutput = output.trim();
+        if (cleanOutput.match(/^\d+\.\d+\.\d+/)) {
+            return cleanOutput.split('\n')[0]; // First line if multiple lines
+        }
+        // Try to parse as JSON if it looks like JSON
+        try {
+            const parsed = JSON.parse(cleanOutput);
+            return parsed.npm || parsed.version || null;
+        }
+        catch {
+            // If not JSON, try to extract version pattern
+            const match = cleanOutput.match(/(\d+\.\d+\.\d+)/);
+            return match ? match[1] : null;
+        }
+    }
+    return null;
+}
+/**
+ * Validate dependency version against requirements
+ */
+export function validateDependencyVersion(actualVersion, requirements, toolName) {
+    const minComparison = compareVersions(actualVersion, requirements.minimum);
+    const maxComparison = compareVersions(actualVersion, requirements.maximum);
+    // Check minimum version requirement
+    if (minComparison < 0) {
+        return {
+            valid: false,
+            error: `${toolName} version ${actualVersion} is below minimum required version ${requirements.minimum}`
+        };
+    }
+    // Check maximum version requirement
+    if (maxComparison > 0) {
+        return {
+            valid: false,
+            error: `${toolName} version ${actualVersion} is above maximum tested version ${requirements.maximum}`
+        };
+    }
+    // Check if it's the recommended version
+    const recComparison = compareVersions(actualVersion, requirements.recommended);
+    if (recComparison !== 0) {
+        return {
+            valid: true,
+            warning: `${toolName} version ${actualVersion} works but ${requirements.recommended} is recommended for optimal stability`
+        };
+    }
+    return { valid: true };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"version.js","sourceRoot":"","sources":["../../../../src/utils/version.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Version comparison and parsing utilities\n */\n\n/**\n * Compare two semantic versions\n * @returns -1 if version1 < version2, 0 if equal, 1 if version1 > version2\n */\nexport function compareVersions(version1: string, version2: string): number {\n  // Normalize versions by removing 'v' prefix\n  const v1 = version1.replace(/^v/, '');\n  const v2 = version2.replace(/^v/, '');\n  \n  // Split version and pre-release parts\n  const [v1main, v1pre] = v1.split('-');\n  const [v2main, v2pre] = v2.split('-');\n  \n  // Compare main version parts (x.y.z)\n  const v1parts = v1main.split('.').map(part => parseInt(part) || 0);\n  const v2parts = v2main.split('.').map(part => parseInt(part) || 0);\n  \n  const maxLength = Math.max(v1parts.length, v2parts.length);\n  for (let i = 0; i < maxLength; i++) {\n    const v1part = v1parts[i] || 0;\n    const v2part = v2parts[i] || 0;\n    \n    if (v1part < v2part) return -1;\n    if (v1part > v2part) return 1;\n  }\n  \n  // If main versions are equal, compare pre-release versions\n  // Version without pre-release is greater than version with pre-release\n  if (!v1pre && v2pre) return 1;   // 1.0.0 > 1.0.0-beta\n  if (v1pre && !v2pre) return -1;  // 1.0.0-beta < 1.0.0\n  if (!v1pre && !v2pre) return 0;  // 1.0.0 == 1.0.0\n  \n  // Both have pre-release, compare lexicographically\n  return v1pre.localeCompare(v2pre);\n}\n\n/**\n * Parse version from command output\n */\nexport function parseVersionFromOutput(output: string, tool: string): string | null {\n  // Git version output: \"git version 2.39.2\"\n  // npm version output: \"8.19.2\" or JSON with version info\n  \n  if (tool === 'git') {\n    const match = output.match(/git version (\\d+\\.\\d+\\.\\d+)/);\n    return match ? match[1] : null;\n  } else if (tool === 'npm') {\n    // npm might return just the version number or JSON\n    const cleanOutput = output.trim();\n    if (cleanOutput.match(/^\\d+\\.\\d+\\.\\d+/)) {\n      return cleanOutput.split('\\n')[0]; // First line if multiple lines\n    }\n    // Try to parse as JSON if it looks like JSON\n    try {\n      const parsed = JSON.parse(cleanOutput);\n      return parsed.npm || parsed.version || null;\n    } catch {\n      // If not JSON, try to extract version pattern\n      const match = cleanOutput.match(/(\\d+\\.\\d+\\.\\d+)/);\n      return match ? match[1] : null;\n    }\n  }\n  \n  return null;\n}\n\n/**\n * Validate dependency version against requirements\n */\nexport function validateDependencyVersion(\n  actualVersion: string, \n  requirements: { minimum: string; maximum: string; recommended: string },\n  toolName: string\n): { valid: boolean; warning?: string; error?: string } {\n  const minComparison = compareVersions(actualVersion, requirements.minimum);\n  const maxComparison = compareVersions(actualVersion, requirements.maximum);\n  \n  // Check minimum version requirement\n  if (minComparison < 0) {\n    return {\n      valid: false,\n      error: `${toolName} version ${actualVersion} is below minimum required version ${requirements.minimum}`\n    };\n  }\n  \n  // Check maximum version requirement\n  if (maxComparison > 0) {\n    return {\n      valid: false,\n      error: `${toolName} version ${actualVersion} is above maximum tested version ${requirements.maximum}`\n    };\n  }\n  \n  // Check if it's the recommended version\n  const recComparison = compareVersions(actualVersion, requirements.recommended);\n  if (recComparison !== 0) {\n    return {\n      valid: true,\n      warning: `${toolName} version ${actualVersion} works but ${requirements.recommended} is recommended for optimal stability`\n    };\n  }\n  \n  return { valid: true };\n}"]}

package/dist/test/test/__tests__/integration/helpers/file-utils.d.ts

@@ -0,0 +1,33 @@
+/**
+ * File system utilities for integration tests
+ */
+import { Persona } from '../../../../src/types/persona.js';
+/**
+ * Create a test persona file
+ */
+export declare function createTestPersonaFile(personasDir: string, persona: Persona): Promise<string>;
+/**
+ * Create multiple test persona files
+ */
+export declare function createTestPersonaFiles(personasDir: string, personas: Persona[]): Promise<string[]>;
+/**
+ * Clean a directory
+ */
+export declare function cleanDirectory(dir: string): Promise<void>;
+/**
+ * Check if a file exists
+ */
+export declare function fileExists(filePath: string): Promise<boolean>;
+/**
+ * Read a persona file and parse it
+ */
+export declare function readPersonaFile(filePath: string): Promise<any>;
+/**
+ * Wait for a file to exist (useful for async operations)
+ */
+export declare function waitForFile(filePath: string, timeout?: number): Promise<void>;
+/**
+ * Create a temporary directory for a test
+ */
+export declare function createTempDir(prefix: string): Promise<string>;
+//# sourceMappingURL=file-utils.d.ts.map

package/dist/test/test/__tests__/integration/helpers/file-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-utils.d.ts","sourceRoot":"","sources":["../../../../../../test/__tests__/integration/helpers/file-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAG3D;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,MAAM,CAAC,CAKjB;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,OAAO,EAAE,GAClB,OAAO,CAAC,MAAM,EAAE,CAAC,CAInB;AAED;;GAEG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAS/D;AAED;;GAEG;AACH,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOnE;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAQpE;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,MAAa,GACrB,OAAO,CAAC,IAAI,CAAC,CAWf;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CASnE"}