@dollhousemcp/mcp-server 1.7.3 → 1.8.0

package/dist/sync/PortfolioSyncComparer.js

@@ -0,0 +1,158 @@
+/**
+ * PortfolioSyncComparer - Compares local and GitHub portfolio elements
+ *
+ * Determines what actions need to be taken based on the sync mode:
+ * - additive: Only add missing elements
+ * - mirror: Make local exactly match GitHub
+ * - backup: Treat GitHub as authoritative source
+ */
+import { logger } from '../utils/logger.js';
+export class PortfolioSyncComparer {
+    /**
+     * Compare GitHub and local elements to determine sync actions
+     */
+    compareElements(githubElements, localElements, mode) {
+        const actions = {
+            toAdd: [],
+            toUpdate: [],
+            toDelete: [],
+            toSkip: []
+        };
+        logger.info('Comparing elements', {
+            githubCount: this.countElements(githubElements),
+            localCount: this.countElements(localElements),
+            mode
+        });
+        // Process each element type
+        const allTypes = new Set([
+            ...githubElements.keys(),
+            ...localElements.keys()
+        ]);
+        for (const type of allTypes) {
+            const githubTypeElements = githubElements.get(type) || [];
+            const localTypeElements = localElements.get(type) || [];
+            this.compareTypeElements(type, githubTypeElements, localTypeElements, mode, actions);
+        }
+        logger.info('Comparison complete', {
+            toAdd: actions.toAdd.length,
+            toUpdate: actions.toUpdate.length,
+            toDelete: actions.toDelete.length,
+            toSkip: actions.toSkip.length
+        });
+        return actions;
+    }
+    /**
+     * Compare elements of a specific type
+     */
+    compareTypeElements(type, githubElements, localElements, mode, actions) {
+        // Create maps for efficient lookup
+        const githubMap = new Map(githubElements.map(e => [this.normalizeElementName(e.name), e]));
+        const localMap = new Map(localElements.map(e => [this.normalizeElementName(e.name || e.metadata?.name), e]));
+        // Process GitHub elements (additions and updates)
+        for (const [name, githubElement] of githubMap) {
+            const localElement = localMap.get(name);
+            if (!localElement) {
+                // Element exists on GitHub but not locally
+                actions.toAdd.push({
+                    type,
+                    name: githubElement.name,
+                    path: githubElement.path,
+                    action: 'add',
+                    remoteSha: githubElement.sha
+                });
+            }
+            else if (mode === 'backup' || this.shouldUpdate(githubElement, localElement, mode)) {
+                // Element needs updating
+                actions.toUpdate.push({
+                    type,
+                    name: githubElement.name,
+                    path: githubElement.path,
+                    action: 'update',
+                    reason: mode === 'backup' ? 'backup mode' : 'newer on GitHub',
+                    localSha: localElement.sha,
+                    remoteSha: githubElement.sha
+                });
+            }
+            else {
+                // Element is up to date or should be skipped
+                actions.toSkip.push({
+                    type,
+                    name: githubElement.name,
+                    path: githubElement.path,
+                    action: 'skip',
+                    reason: 'up to date',
+                    localSha: localElement.sha,
+                    remoteSha: githubElement.sha
+                });
+            }
+        }
+        // Process local elements (deletions - only in mirror mode)
+        if (mode === 'mirror') {
+            for (const [name, localElement] of localMap) {
+                if (!githubMap.has(name)) {
+                    // Element exists locally but not on GitHub
+                    actions.toDelete.push({
+                        type,
+                        name: localElement.name || localElement.metadata?.name || name,
+                        path: `${type}/${name}.md`,
+                        action: 'delete',
+                        reason: 'not on GitHub',
+                        localSha: localElement.sha
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * Determine if an element should be updated
+     */
+    shouldUpdate(githubElement, localElement, mode) {
+        // In backup mode, always update from GitHub
+        if (mode === 'backup') {
+            return true;
+        }
+        // In additive mode, never update existing elements
+        if (mode === 'additive') {
+            return false;
+        }
+        // In mirror mode, update if SHAs differ
+        // If we don't have SHAs, compare modified dates
+        if (githubElement.sha && localElement.sha) {
+            return githubElement.sha !== localElement.sha;
+        }
+        // Compare modified dates if available
+        if (githubElement.lastModified && localElement.lastModified) {
+            const githubDate = new Date(githubElement.lastModified).getTime();
+            const localDate = new Date(localElement.lastModified).getTime();
+            return githubDate > localDate;
+        }
+        // If we can't determine, skip updating in mirror mode
+        return false;
+    }
+    /**
+     * Normalize element name for comparison
+     * Handles different naming formats and extensions
+     */
+    normalizeElementName(name) {
+        if (!name)
+            return '';
+        // Remove .md extension if present
+        let normalized = name.replace(/\.md$/i, '');
+        // Convert to lowercase for comparison
+        normalized = normalized.toLowerCase();
+        // Replace spaces with hyphens (some systems use different formats)
+        normalized = normalized.replace(/\s+/g, '-');
+        return normalized;
+    }
+    /**
+     * Count total elements in a map
+     */
+    countElements(elements) {
+        let count = 0;
+        for (const typeElements of elements.values()) {
+            count += typeElements.length;
+        }
+        return count;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PortfolioSyncComparer.js","sourceRoot":"","sources":["../../src/sync/PortfolioSyncComparer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * PortfolioSyncComparer - Compares local and GitHub portfolio elements\n * \n * Determines what actions need to be taken based on the sync mode:\n * - additive: Only add missing elements\n * - mirror: Make local exactly match GitHub\n * - backup: Treat GitHub as authoritative source\n */\n\nimport { ElementType } from '../portfolio/types.js';\nimport { GitHubIndexEntry } from '../portfolio/GitHubPortfolioIndexer.js';\nimport { logger } from '../utils/logger.js';\n\nexport type SyncMode = 'additive' | 'mirror' | 'backup';\n\nexport interface SyncAction {\n  type: ElementType;\n  name: string;\n  path: string;\n  action: 'add' | 'update' | 'delete' | 'skip';\n  reason?: string;\n  localSha?: string;\n  remoteSha?: string;\n}\n\nexport interface SyncActions {\n  toAdd: SyncAction[];\n  toUpdate: SyncAction[];\n  toDelete: SyncAction[];\n  toSkip: SyncAction[];\n}\n\nexport class PortfolioSyncComparer {\n  /**\n   * Compare GitHub and local elements to determine sync actions\n   */\n  compareElements(\n    githubElements: Map<ElementType, GitHubIndexEntry[]>,\n    localElements: Map<ElementType, any[]>,\n    mode: SyncMode\n  ): SyncActions {\n    const actions: SyncActions = {\n      toAdd: [],\n      toUpdate: [],\n      toDelete: [],\n      toSkip: []\n    };\n\n    logger.info('Comparing elements', { \n      githubCount: this.countElements(githubElements),\n      localCount: this.countElements(localElements),\n      mode \n    });\n\n    // Process each element type\n    const allTypes = new Set([\n      ...githubElements.keys(),\n      ...localElements.keys()\n    ]);\n\n    for (const type of allTypes) {\n      const githubTypeElements = githubElements.get(type) || [];\n      const localTypeElements = localElements.get(type) || [];\n      \n      this.compareTypeElements(\n        type,\n        githubTypeElements,\n        localTypeElements,\n        mode,\n        actions\n      );\n    }\n\n    logger.info('Comparison complete', {\n      toAdd: actions.toAdd.length,\n      toUpdate: actions.toUpdate.length,\n      toDelete: actions.toDelete.length,\n      toSkip: actions.toSkip.length\n    });\n\n    return actions;\n  }\n\n  /**\n   * Compare elements of a specific type\n   */\n  private compareTypeElements(\n    type: ElementType,\n    githubElements: GitHubIndexEntry[],\n    localElements: any[],\n    mode: SyncMode,\n    actions: SyncActions\n  ): void {\n    // Create maps for efficient lookup\n    const githubMap = new Map(\n      githubElements.map(e => [this.normalizeElementName(e.name), e])\n    );\n    const localMap = new Map(\n      localElements.map(e => [this.normalizeElementName(e.name || e.metadata?.name), e])\n    );\n\n    // Process GitHub elements (additions and updates)\n    for (const [name, githubElement] of githubMap) {\n      const localElement = localMap.get(name);\n      \n      if (!localElement) {\n        // Element exists on GitHub but not locally\n        actions.toAdd.push({\n          type,\n          name: githubElement.name,\n          path: githubElement.path,\n          action: 'add',\n          remoteSha: githubElement.sha\n        });\n      } else if (mode === 'backup' || this.shouldUpdate(githubElement, localElement, mode)) {\n        // Element needs updating\n        actions.toUpdate.push({\n          type,\n          name: githubElement.name,\n          path: githubElement.path,\n          action: 'update',\n          reason: mode === 'backup' ? 'backup mode' : 'newer on GitHub',\n          localSha: localElement.sha,\n          remoteSha: githubElement.sha\n        });\n      } else {\n        // Element is up to date or should be skipped\n        actions.toSkip.push({\n          type,\n          name: githubElement.name,\n          path: githubElement.path,\n          action: 'skip',\n          reason: 'up to date',\n          localSha: localElement.sha,\n          remoteSha: githubElement.sha\n        });\n      }\n    }\n\n    // Process local elements (deletions - only in mirror mode)\n    if (mode === 'mirror') {\n      for (const [name, localElement] of localMap) {\n        if (!githubMap.has(name)) {\n          // Element exists locally but not on GitHub\n          actions.toDelete.push({\n            type,\n            name: localElement.name || localElement.metadata?.name || name,\n            path: `${type}/${name}.md`,\n            action: 'delete',\n            reason: 'not on GitHub',\n            localSha: localElement.sha\n          });\n        }\n      }\n    }\n  }\n\n  /**\n   * Determine if an element should be updated\n   */\n  private shouldUpdate(\n    githubElement: GitHubIndexEntry,\n    localElement: any,\n    mode: SyncMode\n  ): boolean {\n    // In backup mode, always update from GitHub\n    if (mode === 'backup') {\n      return true;\n    }\n\n    // In additive mode, never update existing elements\n    if (mode === 'additive') {\n      return false;\n    }\n\n    // In mirror mode, update if SHAs differ\n    // If we don't have SHAs, compare modified dates\n    if (githubElement.sha && localElement.sha) {\n      return githubElement.sha !== localElement.sha;\n    }\n\n    // Compare modified dates if available\n    if (githubElement.lastModified && localElement.lastModified) {\n      const githubDate = new Date(githubElement.lastModified).getTime();\n      const localDate = new Date(localElement.lastModified).getTime();\n      return githubDate > localDate;\n    }\n\n    // If we can't determine, skip updating in mirror mode\n    return false;\n  }\n\n  /**\n   * Normalize element name for comparison\n   * Handles different naming formats and extensions\n   */\n  private normalizeElementName(name: string): string {\n    if (!name) return '';\n    \n    // Remove .md extension if present\n    let normalized = name.replace(/\\.md$/i, '');\n    \n    // Convert to lowercase for comparison\n    normalized = normalized.toLowerCase();\n    \n    // Replace spaces with hyphens (some systems use different formats)\n    normalized = normalized.replace(/\\s+/g, '-');\n    \n    return normalized;\n  }\n\n  /**\n   * Count total elements in a map\n   */\n  private countElements(elements: Map<ElementType, any[]>): number {\n    let count = 0;\n    for (const typeElements of elements.values()) {\n      count += typeElements.length;\n    }\n    return count;\n  }\n}"]}

package/dist/tools/portfolio/submitToPortfolioTool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"submitToPortfolioTool.d.ts","sourceRoot":"","sources":["../../../src/tools/portfolio/submitToPortfolioTool.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AASH,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAIvD,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAInD,OAAO,EAIL,wBAAwB,EAGzB,MAAM,qCAAqC,CAAC;AAQ7C,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,WAAW,CAAC;IAClB,QAAQ,EAAE,wBAAwB,CAAC;IACnC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,qBAAqB,EAAE,CAAC;CAClC;AAwBD,qBAAa,qBAAqB;IAChC,OAAO,CAAC,WAAW,CAAoB;IACvC,OAAO,CAAC,gBAAgB,CAAuB;gBAEnC,QAAQ,EAAE,QAAQ;IAQ9B;;;;OAIG;YACW,0BAA0B;IA8BxC;;;OAGG;YACW,mBAAmB;IA2BjC;;;;;;OAMG;YACW,gCAAgC;IAuH9C;;;;OAIG;YACW,sBAAsB;IA+DpC;;;;;;OAMG;YACW,sBAAsB;IA2EpC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAoC5B;;;;;;OAMG;YACW,sBAAsB;IAiEpC;;;;;OAKG;YACW,wBAAwB;IAsItC;;;;;OAKG;YACW,qBAAqB;IA2NnC;;;;;;;;;OASG;YACW,2BAA2B;IA4GzC;;;OAGG;IACH,OAAO,CAAC,0BAA0B;IAwBlC;;;;OAIG;YACW,qBAAqB;IA+CnC;;;;;;;OAOG;YACW,oBAAoB;IA8DlC;;;;;;OAMG;YACW,kBAAkB;IAkDhC;;;;;;;;OAQG;YACW,8BAA8B;IAoJtC,OAAO,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAkJhF;;;OAGG;YACW,6BAA6B;IAuE3C;;;OAGG;YACW,qBAAqB;YA4RrB,gBAAgB;IA2G9B;;;;;;;OAOG;YACW,iBAAiB;IAoH/B;;;;OAIG;YACW,uBAAuB;IA8HrC;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAwB3B;;;OAGG;YACW,oBAAoB;IAyElC;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;CAmDzB"}
+{"version":3,"file":"submitToPortfolioTool.d.ts","sourceRoot":"","sources":["../../../src/tools/portfolio/submitToPortfolioTool.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAUH,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAIvD,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAInD,OAAO,EAIL,wBAAwB,EAGzB,MAAM,qCAAqC,CAAC;AAQ7C,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,WAAW,CAAC;IAClB,QAAQ,EAAE,wBAAwB,CAAC;IACnC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,qBAAqB,EAAE,CAAC;CAClC;AAwBD,qBAAa,qBAAqB;IAChC,OAAO,CAAC,WAAW,CAAoB;IACvC,OAAO,CAAC,gBAAgB,CAAuB;gBAEnC,QAAQ,EAAE,QAAQ;IAQ9B;;;;OAIG;YACW,0BAA0B;IA8BxC;;;OAGG;YACW,mBAAmB;IA2BjC;;;;;;OAMG;YACW,gCAAgC;IAuH9C;;;;OAIG;YACW,sBAAsB;IA+DpC;;;;;;OAMG;YACW,sBAAsB;IA2EpC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAoC5B;;;;;;OAMG;YACW,sBAAsB;IAiEpC;;;;;OAKG;YACW,wBAAwB;IAsItC;;;;;OAKG;YACW,qBAAqB;IA2NnC;;;;;;;;;OASG;YACW,2BAA2B;IA4GzC;;;OAGG;IACH,OAAO,CAAC,0BAA0B;IAwBlC;;;;OAIG;YACW,qBAAqB;IA+CnC;;;;;;;OAOG;YACW,oBAAoB;IA8DlC;;;;;;OAMG;YACW,kBAAkB;IAkDhC;;;;;;;;OAQG;YACW,8BAA8B;IAoJtC,OAAO,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAkJhF;;;OAGG;YACW,6BAA6B;IAuE3C;;;OAGG;YACW,qBAAqB;YA4RrB,gBAAgB;IA2G9B;;;;;;;OAOG;YACW,iBAAiB;IAoH/B;;;;OAIG;YACW,uBAAuB;IA8HrC;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAwB3B;;;OAGG;YACW,oBAAoB;IAyElC;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;CAmDzB"}