@dollhousemcp/mcp-server 1.4.1 → 1.4.2

package/dist/update/VersionManager.d.ts

@@ -3,7 +3,7 @@
  */
 export declare class VersionManager {
     /**
-     * Get current version from package.json
+     * Get current version from package.json or embedded version
      */
     getCurrentVersion(): Promise<string>;
     /**

package/dist/update/VersionManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VersionManager.d.ts","sourceRoot":"","sources":["../../src/update/VersionManager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,qBAAa,cAAc;IACzB;;OAEG;IACG,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;IAgC1C;;;OAGG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM;IAgC3D;;OAEG;IACH,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IA2BnE;;OAEG;IACH,yBAAyB,CACvB,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,EACvE,QAAQ,EAAE,MAAM,GACf;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE;CAgCxD"}
+{"version":3,"file":"VersionManager.d.ts","sourceRoot":"","sources":["../../src/update/VersionManager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,qBAAa,cAAc;IACzB;;OAEG;IACG,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;IA4E1C;;;OAGG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM;IAgC3D;;OAEG;IACH,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IA2BnE;;OAEG;IACH,yBAAyB,CACvB,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,EACvE,QAAQ,EAAE,MAAM,GACf;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE;CAgCxD"}

package/dist/update/VersionManager.js

@@ -3,38 +3,85 @@
  */
 import * as fs from 'fs/promises';
 import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { logger } from '../utils/logger.js';
+import { InstallationDetector } from '../utils/installation.js';
 export class VersionManager {
     /**
-     * Get current version from package.json
+     * Get current version from package.json or embedded version
      */
     async getCurrentVersion() {
-        // Use process.cwd() as a base, then search upward for package.json
+        // First, try to import the generated version file
+        try {
+            const { PACKAGE_VERSION } = await import('../generated/version.js');
+            if (PACKAGE_VERSION) {
+                logger.debug(`[VersionManager] Using embedded version: ${PACKAGE_VERSION}`);
+                return PACKAGE_VERSION;
+            }
+        }
+        catch (error) {
+            logger.debug('[VersionManager] No embedded version found, will search for package.json');
+        }
+        // Determine installation type
+        const installationType = InstallationDetector.getInstallationType();
+        // For npm installations, look relative to the module location
+        if (installationType === 'npm') {
+            const npmPath = InstallationDetector.getNpmGlobalPath();
+            if (npmPath) {
+                const packageJsonPath = path.join(npmPath, 'package.json');
+                try {
+                    const packageContent = await fs.readFile(packageJsonPath, 'utf-8');
+                    const packageData = JSON.parse(packageContent);
+                    return packageData.version;
+                }
+                catch (error) {
+                    logger.error('[VersionManager] Error reading package.json from npm path:', error);
+                }
+            }
+        }
+        // For git installations, search from current file location
+        if (installationType === 'git') {
+            const currentFileUrl = import.meta.url;
+            const currentFilePath = fileURLToPath(currentFileUrl);
+            let currentDir = path.dirname(currentFilePath);
+            // Search upward for package.json
+            for (let i = 0; i < 5; i++) {
+                const candidatePath = path.join(currentDir, 'package.json');
+                try {
+                    await fs.access(candidatePath);
+                    const packageContent = await fs.readFile(candidatePath, 'utf-8');
+                    const packageData = JSON.parse(packageContent);
+                    return packageData.version;
+                }
+                catch {
+                    // File doesn't exist, try parent directory
+                    const parentDir = path.dirname(currentDir);
+                    if (parentDir === currentDir) {
+                        break;
+                    }
+                    currentDir = parentDir;
+                }
+            }
+        }
+        // Last resort: try process.cwd() (original behavior)
         let currentDir = process.cwd();
-        let packageJsonPath = null;
-        // Search up to 5 levels for package.json
         for (let i = 0; i < 5; i++) {
             const candidatePath = path.join(currentDir, 'package.json');
             try {
                 await fs.access(candidatePath);
-                packageJsonPath = candidatePath;
-                break;
+                const packageContent = await fs.readFile(candidatePath, 'utf-8');
+                const packageData = JSON.parse(packageContent);
+                return packageData.version;
             }
             catch {
-                // File doesn't exist, try parent directory
                 const parentDir = path.dirname(currentDir);
                 if (parentDir === currentDir) {
-                    // We've reached the root
                     break;
                 }
                 currentDir = parentDir;
             }
         }
-        if (!packageJsonPath) {
-            throw new Error('Could not find package.json in current directory or any parent directory');
-        }
-        const packageContent = await fs.readFile(packageJsonPath, 'utf-8');
-        const packageData = JSON.parse(packageContent);
-        return packageData.version;
+        throw new Error('Could not determine version. Please ensure you have a valid installation.');
     }
     /**
      * Enhanced semantic version comparison supporting pre-release versions
@@ -131,4 +178,4 @@ export class VersionManager {
         return { valid: true };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"VersionManager.js","sourceRoot":"","sources":["../../src/update/VersionManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Version management and comparison utilities\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\n\nexport class VersionManager {\n  /**\n   * Get current version from package.json\n   */\n  async getCurrentVersion(): Promise<string> {\n    // Use process.cwd() as a base, then search upward for package.json\n    let currentDir = process.cwd();\n    let packageJsonPath: string | null = null;\n    \n    // Search up to 5 levels for package.json\n    for (let i = 0; i < 5; i++) {\n      const candidatePath = path.join(currentDir, 'package.json');\n      try {\n        await fs.access(candidatePath);\n        packageJsonPath = candidatePath;\n        break;\n      } catch {\n        // File doesn't exist, try parent directory\n        const parentDir = path.dirname(currentDir);\n        if (parentDir === currentDir) {\n          // We've reached the root\n          break;\n        }\n        currentDir = parentDir;\n      }\n    }\n    \n    if (!packageJsonPath) {\n      throw new Error('Could not find package.json in current directory or any parent directory');\n    }\n    \n    const packageContent = await fs.readFile(packageJsonPath, 'utf-8');\n    const packageData = JSON.parse(packageContent);\n    return packageData.version;\n  }\n  \n  /**\n   * Enhanced semantic version comparison supporting pre-release versions\n   * Returns: -1 if v1 < v2, 0 if v1 == v2, 1 if v1 > v2\n   */\n  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 dependency output\n   */\n  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 that a dependency version meets requirements\n   */\n  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 = this.compareVersions(actualVersion, requirements.minimum);\n    const maxComparison = this.compareVersions(actualVersion, requirements.maximum);\n    \n    // Check if version is below minimum\n    if (minComparison < 0) {\n      return {\n        valid: false,\n        error: `${toolName} version ${actualVersion} is below minimum required version ${requirements.minimum}. Please upgrade ${toolName}.`\n      };\n    }\n    \n    // Check if version is above maximum tested\n    if (maxComparison > 0) {\n      return {\n        valid: true,\n        warning: `${toolName} version ${actualVersion} is above maximum tested version ${requirements.maximum}. Some features may not work as expected.`\n      };\n    }\n    \n    // Check if not at recommended version\n    const recComparison = this.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    // Version is perfect\n    return { valid: true };\n  }\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"VersionManager.js","sourceRoot":"","sources":["../../src/update/VersionManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Version management and comparison utilities\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { fileURLToPath } from 'url';\nimport { logger } from '../utils/logger.js';\nimport { InstallationDetector } from '../utils/installation.js';\n\nexport class VersionManager {\n  /**\n   * Get current version from package.json or embedded version\n   */\n  async getCurrentVersion(): Promise<string> {\n    // First, try to import the generated version file\n    try {\n      const { PACKAGE_VERSION } = await import('../generated/version.js');\n      if (PACKAGE_VERSION) {\n        logger.debug(`[VersionManager] Using embedded version: ${PACKAGE_VERSION}`);\n        return PACKAGE_VERSION;\n      }\n    } catch (error) {\n      logger.debug('[VersionManager] No embedded version found, will search for package.json');\n    }\n    \n    // Determine installation type\n    const installationType = InstallationDetector.getInstallationType();\n    \n    // For npm installations, look relative to the module location\n    if (installationType === 'npm') {\n      const npmPath = InstallationDetector.getNpmGlobalPath();\n      if (npmPath) {\n        const packageJsonPath = path.join(npmPath, 'package.json');\n        try {\n          const packageContent = await fs.readFile(packageJsonPath, 'utf-8');\n          const packageData = JSON.parse(packageContent);\n          return packageData.version;\n        } catch (error) {\n          logger.error('[VersionManager] Error reading package.json from npm path:', error);\n        }\n      }\n    }\n    \n    // For git installations, search from current file location\n    if (installationType === 'git') {\n      const currentFileUrl = import.meta.url;\n      const currentFilePath = fileURLToPath(currentFileUrl);\n      let currentDir = path.dirname(currentFilePath);\n      \n      // Search upward for package.json\n      for (let i = 0; i < 5; i++) {\n        const candidatePath = path.join(currentDir, 'package.json');\n        try {\n          await fs.access(candidatePath);\n          const packageContent = await fs.readFile(candidatePath, 'utf-8');\n          const packageData = JSON.parse(packageContent);\n          return packageData.version;\n        } catch {\n          // File doesn't exist, try parent directory\n          const parentDir = path.dirname(currentDir);\n          if (parentDir === currentDir) {\n            break;\n          }\n          currentDir = parentDir;\n        }\n      }\n    }\n    \n    // Last resort: try process.cwd() (original behavior)\n    let currentDir = process.cwd();\n    for (let i = 0; i < 5; i++) {\n      const candidatePath = path.join(currentDir, 'package.json');\n      try {\n        await fs.access(candidatePath);\n        const packageContent = await fs.readFile(candidatePath, 'utf-8');\n        const packageData = JSON.parse(packageContent);\n        return packageData.version;\n      } catch {\n        const parentDir = path.dirname(currentDir);\n        if (parentDir === currentDir) {\n          break;\n        }\n        currentDir = parentDir;\n      }\n    }\n    \n    throw new Error('Could not determine version. Please ensure you have a valid installation.');\n  }\n  \n  /**\n   * Enhanced semantic version comparison supporting pre-release versions\n   * Returns: -1 if v1 < v2, 0 if v1 == v2, 1 if v1 > v2\n   */\n  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 dependency output\n   */\n  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 that a dependency version meets requirements\n   */\n  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 = this.compareVersions(actualVersion, requirements.minimum);\n    const maxComparison = this.compareVersions(actualVersion, requirements.maximum);\n    \n    // Check if version is below minimum\n    if (minComparison < 0) {\n      return {\n        valid: false,\n        error: `${toolName} version ${actualVersion} is below minimum required version ${requirements.minimum}. Please upgrade ${toolName}.`\n      };\n    }\n    \n    // Check if version is above maximum tested\n    if (maxComparison > 0) {\n      return {\n        valid: true,\n        warning: `${toolName} version ${actualVersion} is above maximum tested version ${requirements.maximum}. Some features may not work as expected.`\n      };\n    }\n    \n    // Check if not at recommended version\n    const recComparison = this.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    // Version is perfect\n    return { valid: true };\n  }\n}"]}

package/dist/utils/fileOperations.d.ts

@@ -0,0 +1,83 @@
+export interface CopyOptions {
+    onProgress?: (copied: number, total: number, currentFile: string) => void;
+    excludePatterns?: string[];
+    maxRetries?: number;
+}
+export interface FileStats {
+    totalFiles: number;
+    totalSize: number;
+}
+/**
+ * Cross-platform file operations utility
+ * Centralizes common file operations with progress reporting and error handling
+ */
+export declare class FileOperations {
+    /**
+     * Recursively copy a directory with progress reporting
+     * Works cross-platform without relying on shell commands
+     */
+    static copyDirectory(src: string, dest: string, options?: CopyOptions): Promise<void>;
+    /**
+     * Calculate directory statistics for progress reporting
+     */
+    private static calculateDirectoryStats;
+    /**
+     * Internal recursive copy implementation
+     */
+    private static copyDirectoryRecursive;
+    /**
+     * Copy a single file with retry logic
+     */
+    private static copyFileWithRetry;
+    /**
+     * Check if a file/directory should be excluded
+     */
+    private static shouldExclude;
+    /**
+     * Remove a directory with progress reporting
+     */
+    static removeDirectory(dir: string, options?: {
+        onProgress?: (removed: number, total: number) => void;
+    }): Promise<void>;
+    /**
+     * Internal recursive remove implementation
+     */
+    private static removeDirectoryRecursive;
+    /**
+     * Create a transaction manager for atomic file operations
+     */
+    static createTransaction(): FileTransaction;
+}
+/**
+ * Transaction manager for atomic file operations
+ * Ensures all operations succeed or all are rolled back
+ */
+export declare class FileTransaction {
+    private operations;
+    private completed;
+    /**
+     * Add a move operation to the transaction
+     */
+    addMove(source: string, destination: string): Promise<void>;
+    /**
+     * Add a copy operation to the transaction
+     */
+    addCopy(source: string, destination: string): Promise<void>;
+    /**
+     * Add a delete operation to the transaction
+     */
+    addDelete(path: string, backupPath?: string): Promise<void>;
+    /**
+     * Commit the transaction (mark as successful)
+     */
+    commit(): void;
+    /**
+     * Rollback all operations in reverse order
+     */
+    rollback(): Promise<void>;
+    /**
+     * Check if any operations have been performed
+     */
+    hasOperations(): boolean;
+}
+//# sourceMappingURL=fileOperations.d.ts.map

package/dist/utils/fileOperations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileOperations.d.ts","sourceRoot":"","sources":["../../src/utils/fileOperations.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,WAAW;IAC1B,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1E,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,SAAS;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,qBAAa,cAAc;IACzB;;;OAGG;WACU,aAAa,CACxB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,WAAgB,GACxB,OAAO,CAAC,IAAI,CAAC;IAqBhB;;OAEG;mBACkB,uBAAuB;IAuC5C;;OAEG;mBACkB,sBAAsB;IAqC3C;;OAEG;mBACkB,iBAAiB;IA0BtC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,aAAa;IAa5B;;OAEG;WACU,eAAe,CAC1B,GAAG,EAAE,MAAM,EACX,OAAO,GAAE;QAAE,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;KAAO,GACtE,OAAO,CAAC,IAAI,CAAC;IAYhB;;OAEG;mBACkB,wBAAwB;IA0B7C;;OAEG;IACH,MAAM,CAAC,iBAAiB,IAAI,eAAe;CAG5C;AAED;;;GAGG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,UAAU,CAKV;IAER,OAAO,CAAC,SAAS,CAAS;IAE1B;;OAEG;IACG,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBjE;;OAEG;IACG,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBjE;;OAEG;IACG,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmCjE;;OAEG;IACH,MAAM,IAAI,IAAI;IAId;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAmB/B;;OAEG;IACH,aAAa,IAAI,OAAO;CAGzB"}

package/dist/utils/fileOperations.js

@@ -0,0 +1,291 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { logger } from './logger.js';
+/**
+ * Cross-platform file operations utility
+ * Centralizes common file operations with progress reporting and error handling
+ */
+export class FileOperations {
+    /**
+     * Recursively copy a directory with progress reporting
+     * Works cross-platform without relying on shell commands
+     */
+    static async copyDirectory(src, dest, options = {}) {
+        const { onProgress, excludePatterns = [], maxRetries = 3 } = options;
+        // First, calculate total files for progress reporting
+        const stats = await this.calculateDirectoryStats(src, excludePatterns);
+        let copiedFiles = 0;
+        await this.copyDirectoryRecursive(src, dest, excludePatterns, maxRetries, (currentFile) => {
+            copiedFiles++;
+            if (onProgress) {
+                onProgress(copiedFiles, stats.totalFiles, currentFile);
+            }
+        });
+    }
+    /**
+     * Calculate directory statistics for progress reporting
+     */
+    static async calculateDirectoryStats(dir, excludePatterns) {
+        let totalFiles = 0;
+        let totalSize = 0;
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                // Skip excluded patterns
+                if (this.shouldExclude(entry.name, excludePatterns)) {
+                    continue;
+                }
+                if (entry.isDirectory()) {
+                    const subStats = await this.calculateDirectoryStats(fullPath, excludePatterns);
+                    totalFiles += subStats.totalFiles;
+                    totalSize += subStats.totalSize;
+                }
+                else {
+                    totalFiles++;
+                    try {
+                        const stat = await fs.stat(fullPath);
+                        totalSize += stat.size;
+                    }
+                    catch {
+                        // Ignore stat errors
+                    }
+                }
+            }
+        }
+        catch (error) {
+            logger.warn(`[FileOperations] Error calculating stats for ${dir}:`, error);
+        }
+        return { totalFiles, totalSize };
+    }
+    /**
+     * Internal recursive copy implementation
+     */
+    static async copyDirectoryRecursive(src, dest, excludePatterns, maxRetries, onFileCopied) {
+        // Ensure destination directory exists
+        await fs.mkdir(dest, { recursive: true });
+        const entries = await fs.readdir(src, { withFileTypes: true });
+        for (const entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            // Skip excluded patterns
+            if (this.shouldExclude(entry.name, excludePatterns)) {
+                logger.debug(`[FileOperations] Skipping excluded: ${entry.name}`);
+                continue;
+            }
+            if (entry.isDirectory()) {
+                await this.copyDirectoryRecursive(srcPath, destPath, excludePatterns, maxRetries, onFileCopied);
+            }
+            else {
+                await this.copyFileWithRetry(srcPath, destPath, maxRetries);
+                onFileCopied(srcPath);
+            }
+        }
+    }
+    /**
+     * Copy a single file with retry logic
+     */
+    static async copyFileWithRetry(src, dest, maxRetries) {
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                await fs.copyFile(src, dest);
+                return; // Success
+            }
+            catch (error) {
+                lastError = error;
+                logger.debug(`[FileOperations] Copy attempt ${attempt} failed for ${src}: ${error}`);
+                if (attempt < maxRetries) {
+                    // Wait before retry (exponential backoff)
+                    await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 100));
+                }
+            }
+        }
+        // All retries failed
+        throw new Error(`Failed to copy ${src} after ${maxRetries} attempts: ${lastError?.message}`);
+    }
+    /**
+     * Check if a file/directory should be excluded
+     */
+    static shouldExclude(name, patterns) {
+        for (const pattern of patterns) {
+            if (pattern.includes('*')) {
+                // Simple glob support
+                const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+                if (regex.test(name))
+                    return true;
+            }
+            else if (name === pattern) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Remove a directory with progress reporting
+     */
+    static async removeDirectory(dir, options = {}) {
+        const stats = await this.calculateDirectoryStats(dir, []);
+        let removedFiles = 0;
+        await this.removeDirectoryRecursive(dir, () => {
+            removedFiles++;
+            if (options.onProgress) {
+                options.onProgress(removedFiles, stats.totalFiles);
+            }
+        });
+    }
+    /**
+     * Internal recursive remove implementation
+     */
+    static async removeDirectoryRecursive(dir, onFileRemoved) {
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    await this.removeDirectoryRecursive(fullPath, onFileRemoved);
+                }
+                else {
+                    await fs.unlink(fullPath);
+                    onFileRemoved();
+                }
+            }
+            // Remove the now-empty directory
+            await fs.rmdir(dir);
+        }
+        catch (error) {
+            logger.error(`[FileOperations] Error removing directory ${dir}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Create a transaction manager for atomic file operations
+     */
+    static createTransaction() {
+        return new FileTransaction();
+    }
+}
+/**
+ * Transaction manager for atomic file operations
+ * Ensures all operations succeed or all are rolled back
+ */
+export class FileTransaction {
+    operations = [];
+    completed = false;
+    /**
+     * Add a move operation to the transaction
+     */
+    async addMove(source, destination) {
+        if (this.completed) {
+            throw new Error('Transaction already completed');
+        }
+        // Perform the move
+        await fs.rename(source, destination);
+        // Add rollback operation
+        this.operations.push({
+            type: 'move',
+            source,
+            destination,
+            rollback: async () => {
+                try {
+                    await fs.rename(destination, source);
+                }
+                catch (error) {
+                    logger.error(`[FileTransaction] Failed to rollback move from ${destination} to ${source}:`, error);
+                }
+            }
+        });
+    }
+    /**
+     * Add a copy operation to the transaction
+     */
+    async addCopy(source, destination) {
+        if (this.completed) {
+            throw new Error('Transaction already completed');
+        }
+        // Perform the copy
+        await FileOperations.copyDirectory(source, destination);
+        // Add rollback operation
+        this.operations.push({
+            type: 'copy',
+            source,
+            destination,
+            rollback: async () => {
+                try {
+                    await fs.rm(destination, { recursive: true, force: true });
+                }
+                catch (error) {
+                    logger.error(`[FileTransaction] Failed to rollback copy at ${destination}:`, error);
+                }
+            }
+        });
+    }
+    /**
+     * Add a delete operation to the transaction
+     */
+    async addDelete(path, backupPath) {
+        if (this.completed) {
+            throw new Error('Transaction already completed');
+        }
+        // If backup path provided, move instead of delete
+        if (backupPath) {
+            await fs.rename(path, backupPath);
+            this.operations.push({
+                type: 'delete',
+                source: path,
+                destination: backupPath,
+                rollback: async () => {
+                    try {
+                        await fs.rename(backupPath, path);
+                    }
+                    catch (error) {
+                        logger.error(`[FileTransaction] Failed to restore deleted item from ${backupPath} to ${path}:`, error);
+                    }
+                }
+            });
+        }
+        else {
+            // Direct delete (no rollback possible)
+            await fs.rm(path, { recursive: true, force: true });
+            this.operations.push({
+                type: 'delete',
+                source: path,
+                rollback: async () => {
+                    logger.warn(`[FileTransaction] Cannot rollback permanent deletion of ${path}`);
+                }
+            });
+        }
+    }
+    /**
+     * Commit the transaction (mark as successful)
+     */
+    commit() {
+        this.completed = true;
+    }
+    /**
+     * Rollback all operations in reverse order
+     */
+    async rollback() {
+        logger.info(`[FileTransaction] Rolling back ${this.operations.length} operations`);
+        // Rollback in reverse order
+        for (let i = this.operations.length - 1; i >= 0; i--) {
+            const operation = this.operations[i];
+            logger.info(`[FileTransaction] Rolling back ${operation.type} operation`);
+            try {
+                await operation.rollback();
+            }
+            catch (error) {
+                logger.error(`[FileTransaction] Rollback failed for operation ${i}:`, error);
+                // Continue with other rollbacks
+            }
+        }
+        this.completed = true;
+    }
+    /**
+     * Check if any operations have been performed
+     */
+    hasOperations() {
+        return this.operations.length > 0;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fileOperations.js","sourceRoot":"","sources":["../../src/utils/fileOperations.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { logger } from './logger.js';\n\nexport interface CopyOptions {\n  onProgress?: (copied: number, total: number, currentFile: string) => void;\n  excludePatterns?: string[];\n  maxRetries?: number;\n}\n\nexport interface FileStats {\n  totalFiles: number;\n  totalSize: number;\n}\n\n/**\n * Cross-platform file operations utility\n * Centralizes common file operations with progress reporting and error handling\n */\nexport class FileOperations {\n  /**\n   * Recursively copy a directory with progress reporting\n   * Works cross-platform without relying on shell commands\n   */\n  static async copyDirectory(\n    src: string, \n    dest: string, \n    options: CopyOptions = {}\n  ): Promise<void> {\n    const { onProgress, excludePatterns = [], maxRetries = 3 } = options;\n    \n    // First, calculate total files for progress reporting\n    const stats = await this.calculateDirectoryStats(src, excludePatterns);\n    let copiedFiles = 0;\n    \n    await this.copyDirectoryRecursive(\n      src, \n      dest, \n      excludePatterns,\n      maxRetries,\n      (currentFile) => {\n        copiedFiles++;\n        if (onProgress) {\n          onProgress(copiedFiles, stats.totalFiles, currentFile);\n        }\n      }\n    );\n  }\n  \n  /**\n   * Calculate directory statistics for progress reporting\n   */\n  private static async calculateDirectoryStats(\n    dir: string,\n    excludePatterns: string[]\n  ): Promise<FileStats> {\n    let totalFiles = 0;\n    let totalSize = 0;\n    \n    try {\n      const entries = await fs.readdir(dir, { withFileTypes: true });\n      \n      for (const entry of entries) {\n        const fullPath = path.join(dir, entry.name);\n        \n        // Skip excluded patterns\n        if (this.shouldExclude(entry.name, excludePatterns)) {\n          continue;\n        }\n        \n        if (entry.isDirectory()) {\n          const subStats = await this.calculateDirectoryStats(fullPath, excludePatterns);\n          totalFiles += subStats.totalFiles;\n          totalSize += subStats.totalSize;\n        } else {\n          totalFiles++;\n          try {\n            const stat = await fs.stat(fullPath);\n            totalSize += stat.size;\n          } catch {\n            // Ignore stat errors\n          }\n        }\n      }\n    } catch (error) {\n      logger.warn(`[FileOperations] Error calculating stats for ${dir}:`, error);\n    }\n    \n    return { totalFiles, totalSize };\n  }\n  \n  /**\n   * Internal recursive copy implementation\n   */\n  private static async copyDirectoryRecursive(\n    src: string,\n    dest: string,\n    excludePatterns: string[],\n    maxRetries: number,\n    onFileCopied: (file: string) => void\n  ): Promise<void> {\n    // Ensure destination directory exists\n    await fs.mkdir(dest, { recursive: true });\n    \n    const entries = await fs.readdir(src, { withFileTypes: true });\n    \n    for (const entry of entries) {\n      const srcPath = path.join(src, entry.name);\n      const destPath = path.join(dest, entry.name);\n      \n      // Skip excluded patterns\n      if (this.shouldExclude(entry.name, excludePatterns)) {\n        logger.debug(`[FileOperations] Skipping excluded: ${entry.name}`);\n        continue;\n      }\n      \n      if (entry.isDirectory()) {\n        await this.copyDirectoryRecursive(\n          srcPath, \n          destPath, \n          excludePatterns,\n          maxRetries,\n          onFileCopied\n        );\n      } else {\n        await this.copyFileWithRetry(srcPath, destPath, maxRetries);\n        onFileCopied(srcPath);\n      }\n    }\n  }\n  \n  /**\n   * Copy a single file with retry logic\n   */\n  private static async copyFileWithRetry(\n    src: string,\n    dest: string,\n    maxRetries: number\n  ): Promise<void> {\n    let lastError: Error | null = null;\n    \n    for (let attempt = 1; attempt <= maxRetries; attempt++) {\n      try {\n        await fs.copyFile(src, dest);\n        return; // Success\n      } catch (error) {\n        lastError = error as Error;\n        logger.debug(`[FileOperations] Copy attempt ${attempt} failed for ${src}: ${error}`);\n        \n        if (attempt < maxRetries) {\n          // Wait before retry (exponential backoff)\n          await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 100));\n        }\n      }\n    }\n    \n    // All retries failed\n    throw new Error(`Failed to copy ${src} after ${maxRetries} attempts: ${lastError?.message}`);\n  }\n  \n  /**\n   * Check if a file/directory should be excluded\n   */\n  private static shouldExclude(name: string, patterns: string[]): boolean {\n    for (const pattern of patterns) {\n      if (pattern.includes('*')) {\n        // Simple glob support\n        const regex = new RegExp('^' + pattern.replace(/\\*/g, '.*') + '$');\n        if (regex.test(name)) return true;\n      } else if (name === pattern) {\n        return true;\n      }\n    }\n    return false;\n  }\n  \n  /**\n   * Remove a directory with progress reporting\n   */\n  static async removeDirectory(\n    dir: string,\n    options: { onProgress?: (removed: number, total: number) => void } = {}\n  ): Promise<void> {\n    const stats = await this.calculateDirectoryStats(dir, []);\n    let removedFiles = 0;\n    \n    await this.removeDirectoryRecursive(dir, () => {\n      removedFiles++;\n      if (options.onProgress) {\n        options.onProgress(removedFiles, stats.totalFiles);\n      }\n    });\n  }\n  \n  /**\n   * Internal recursive remove implementation\n   */\n  private static async removeDirectoryRecursive(\n    dir: string,\n    onFileRemoved: () => void\n  ): Promise<void> {\n    try {\n      const entries = await fs.readdir(dir, { withFileTypes: true });\n      \n      for (const entry of entries) {\n        const fullPath = path.join(dir, entry.name);\n        \n        if (entry.isDirectory()) {\n          await this.removeDirectoryRecursive(fullPath, onFileRemoved);\n        } else {\n          await fs.unlink(fullPath);\n          onFileRemoved();\n        }\n      }\n      \n      // Remove the now-empty directory\n      await fs.rmdir(dir);\n    } catch (error) {\n      logger.error(`[FileOperations] Error removing directory ${dir}:`, error);\n      throw error;\n    }\n  }\n  \n  /**\n   * Create a transaction manager for atomic file operations\n   */\n  static createTransaction(): FileTransaction {\n    return new FileTransaction();\n  }\n}\n\n/**\n * Transaction manager for atomic file operations\n * Ensures all operations succeed or all are rolled back\n */\nexport class FileTransaction {\n  private operations: Array<{\n    type: 'move' | 'copy' | 'delete' | 'create';\n    source?: string;\n    destination?: string;\n    rollback: () => Promise<void>;\n  }> = [];\n  \n  private completed = false;\n  \n  /**\n   * Add a move operation to the transaction\n   */\n  async addMove(source: string, destination: string): Promise<void> {\n    if (this.completed) {\n      throw new Error('Transaction already completed');\n    }\n    \n    // Perform the move\n    await fs.rename(source, destination);\n    \n    // Add rollback operation\n    this.operations.push({\n      type: 'move',\n      source,\n      destination,\n      rollback: async () => {\n        try {\n          await fs.rename(destination, source);\n        } catch (error) {\n          logger.error(`[FileTransaction] Failed to rollback move from ${destination} to ${source}:`, error);\n        }\n      }\n    });\n  }\n  \n  /**\n   * Add a copy operation to the transaction\n   */\n  async addCopy(source: string, destination: string): Promise<void> {\n    if (this.completed) {\n      throw new Error('Transaction already completed');\n    }\n    \n    // Perform the copy\n    await FileOperations.copyDirectory(source, destination);\n    \n    // Add rollback operation\n    this.operations.push({\n      type: 'copy',\n      source,\n      destination,\n      rollback: async () => {\n        try {\n          await fs.rm(destination, { recursive: true, force: true });\n        } catch (error) {\n          logger.error(`[FileTransaction] Failed to rollback copy at ${destination}:`, error);\n        }\n      }\n    });\n  }\n  \n  /**\n   * Add a delete operation to the transaction\n   */\n  async addDelete(path: string, backupPath?: string): Promise<void> {\n    if (this.completed) {\n      throw new Error('Transaction already completed');\n    }\n    \n    // If backup path provided, move instead of delete\n    if (backupPath) {\n      await fs.rename(path, backupPath);\n      \n      this.operations.push({\n        type: 'delete',\n        source: path,\n        destination: backupPath,\n        rollback: async () => {\n          try {\n            await fs.rename(backupPath, path);\n          } catch (error) {\n            logger.error(`[FileTransaction] Failed to restore deleted item from ${backupPath} to ${path}:`, error);\n          }\n        }\n      });\n    } else {\n      // Direct delete (no rollback possible)\n      await fs.rm(path, { recursive: true, force: true });\n      \n      this.operations.push({\n        type: 'delete',\n        source: path,\n        rollback: async () => {\n          logger.warn(`[FileTransaction] Cannot rollback permanent deletion of ${path}`);\n        }\n      });\n    }\n  }\n  \n  /**\n   * Commit the transaction (mark as successful)\n   */\n  commit(): void {\n    this.completed = true;\n  }\n  \n  /**\n   * Rollback all operations in reverse order\n   */\n  async rollback(): Promise<void> {\n    logger.info(`[FileTransaction] Rolling back ${this.operations.length} operations`);\n    \n    // Rollback in reverse order\n    for (let i = this.operations.length - 1; i >= 0; i--) {\n      const operation = this.operations[i];\n      logger.info(`[FileTransaction] Rolling back ${operation.type} operation`);\n      \n      try {\n        await operation.rollback();\n      } catch (error) {\n        logger.error(`[FileTransaction] Rollback failed for operation ${i}:`, error);\n        // Continue with other rollbacks\n      }\n    }\n    \n    this.completed = true;\n  }\n  \n  /**\n   * Check if any operations have been performed\n   */\n  hasOperations(): boolean {\n    return this.operations.length > 0;\n  }\n}"]}

package/dist/utils/installation.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Installation detection utilities
+ * Determines whether the application is running from npm or git installation
+ */
+export type InstallationType = 'npm' | 'git' | 'unknown';
+export declare class InstallationDetector {
+    private static cachedType;
+    private static get MAX_SEARCH_DEPTH();
+    /**
+     * Detect the installation type (npm global, git clone, or unknown)
+     */
+    static getInstallationType(): InstallationType;
+    /**
+     * Get the npm global installation path if running from npm
+     */
+    static getNpmGlobalPath(): string | null;
+    /**
+     * Get the git repository root path if running from git
+     */
+    static getGitRepositoryPath(): string | null;
+    /**
+     * Get a human-readable description of the installation
+     */
+    static getInstallationDescription(): string;
+    /**
+     * Clear the cached installation type (mainly for testing)
+     */
+    static clearCache(): void;
+}
+//# sourceMappingURL=installation.d.ts.map

package/dist/utils/installation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"installation.d.ts","sourceRoot":"","sources":["../../src/utils/installation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,MAAM,MAAM,gBAAgB,GAAG,KAAK,GAAG,KAAK,GAAG,SAAS,CAAC;AAEzD,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAC,UAAU,CAAiC;IAG1D,OAAO,CAAC,MAAM,KAAK,gBAAgB,GAElC;IAED;;OAEG;IACH,MAAM,CAAC,mBAAmB,IAAI,gBAAgB;IA8D9C;;OAEG;IACH,MAAM,CAAC,gBAAgB,IAAI,MAAM,GAAG,IAAI;IA2BxC;;OAEG;IACH,MAAM,CAAC,oBAAoB,IAAI,MAAM,GAAG,IAAI;IA4B5C;;OAEG;IACH,MAAM,CAAC,0BAA0B,IAAI,MAAM;IAqB3C;;OAEG;IACH,MAAM,CAAC,UAAU,IAAI,IAAI;CAG1B"}