@documentation-robotics/cli 0.1.0

package/dist/core/changeset.js

@@ -0,0 +1,244 @@
+import { readJSON, writeJSON, ensureDir, fileExists } from "../utils/file-io.js";
+import { Element } from "./element.js";
+class Changeset {
+  name;
+  description;
+  created;
+  modified;
+  changes = [];
+  status = "draft";
+  constructor(data) {
+    this.name = data.name, this.description = data.description, this.created = data.created, this.modified = data.modified, this.changes = data.changes || [], this.status = data.status || "draft";
+  }
+  /**
+   * Create a new changeset
+   */
+  static create(name, description) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return new Changeset({
+      name,
+      description,
+      created: now,
+      modified: now,
+      changes: [],
+      status: "draft"
+    });
+  }
+  /**
+   * Add a change to the changeset
+   */
+  addChange(type, elementId, layerName, before, after) {
+    this.changes.push({
+      type,
+      elementId,
+      layerName,
+      before,
+      after,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }), this.updateModified();
+  }
+  /**
+   * Update the modified timestamp
+   */
+  updateModified() {
+    this.modified = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  /**
+   * Get number of changes
+   */
+  getChangeCount() {
+    return this.changes.length;
+  }
+  /**
+   * Get changes by type
+   */
+  getChangesByType(type) {
+    return this.changes.filter((c) => c.type === type);
+  }
+  /**
+   * Mark changeset as applied
+   */
+  markApplied() {
+    this.status = "applied", this.updateModified();
+  }
+  /**
+   * Mark changeset as reverted
+   */
+  markReverted() {
+    this.status = "reverted", this.updateModified();
+  }
+  /**
+   * Serialize to JSON
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      description: this.description,
+      created: this.created,
+      modified: this.modified,
+      changes: this.changes,
+      status: this.status
+    };
+  }
+  /**
+   * Create from JSON data
+   */
+  static fromJSON(data) {
+    return new Changeset(data);
+  }
+}
+class ChangesetManager {
+  changesetsDir;
+  constructor(modelPath) {
+    this.changesetsDir = `${modelPath}/.dr/changesets`;
+  }
+  /**
+   * Create a new changeset
+   */
+  async create(name, description) {
+    const changeset = Changeset.create(name, description);
+    return await this.save(changeset), changeset;
+  }
+  /**
+   * Save a changeset to disk
+   */
+  async save(changeset) {
+    await ensureDir(this.changesetsDir);
+    const filePath = `${this.changesetsDir}/${this.sanitizeName(changeset.name)}.json`;
+    await writeJSON(filePath, changeset.toJSON(), !0);
+  }
+  /**
+   * Load a changeset by name
+   */
+  async load(name) {
+    const filePath = `${this.changesetsDir}/${this.sanitizeName(name)}.json`;
+    if (!await fileExists(filePath))
+      return null;
+    const data = await readJSON(filePath);
+    return Changeset.fromJSON(data);
+  }
+  /**
+   * List all changesets
+   */
+  async list() {
+    if (!await fileExists(this.changesetsDir))
+      return [];
+    const files = await (await import("fs/promises")).readdir(this.changesetsDir), changesets = [];
+    for (const file of files)
+      if (file.endsWith(".json")) {
+        const data = await readJSON(`${this.changesetsDir}/${file}`);
+        changesets.push(Changeset.fromJSON(data));
+      }
+    return changesets;
+  }
+  /**
+   * Delete a changeset
+   */
+  async delete(name) {
+    const filePath = `${this.changesetsDir}/${this.sanitizeName(name)}.json`;
+    if (!await fileExists(filePath))
+      throw new Error(`Changeset '${name}' not found`);
+    await (await import("fs/promises")).unlink(filePath);
+  }
+  /**
+   * Apply a changeset to the model
+   */
+  async apply(model, name) {
+    const changeset = await this.load(name);
+    if (!changeset)
+      throw new Error(`Changeset '${name}' not found`);
+    const result = {
+      changeset: name,
+      applied: 0,
+      failed: 0,
+      errors: []
+    };
+    for (const change of changeset.changes)
+      try {
+        const layer = await model.getLayer(change.layerName);
+        if (!layer)
+          throw new Error(`Layer '${change.layerName}' not found`);
+        if (change.type === "add" && change.after) {
+          if (!layer.listElements().some((e) => e.id === change.elementId)) {
+            const elementData = change.after, element = new Element({
+              id: change.elementId,
+              type: elementData.type || "unknown",
+              name: elementData.name || change.elementId,
+              description: elementData.description,
+              properties: elementData
+            });
+            layer.addElement(element), result.applied++;
+          }
+        } else if (change.type === "update" && change.after) {
+          const element = layer.getElement(change.elementId);
+          if (element) {
+            const elementData = change.after;
+            Object.assign(element, elementData), result.applied++;
+          }
+        } else change.type === "delete" && layer.getElement(change.elementId) && (layer.deleteElement(change.elementId), result.applied++);
+      } catch (error) {
+        result.failed++, result.errors.push({
+          change,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    return result.failed === 0 && (changeset.markApplied(), await this.save(changeset)), result;
+  }
+  /**
+   * Revert a changeset from the model
+   */
+  async revert(model, name) {
+    const changeset = await this.load(name);
+    if (!changeset)
+      throw new Error(`Changeset '${name}' not found`);
+    const result = {
+      changeset: name,
+      reverted: 0,
+      failed: 0,
+      errors: []
+    };
+    for (let i = changeset.changes.length - 1; i >= 0; i--) {
+      const change = changeset.changes[i];
+      try {
+        const layer = await model.getLayer(change.layerName);
+        if (!layer)
+          throw new Error(`Layer '${change.layerName}' not found`);
+        if (change.type === "add")
+          layer.getElement(change.elementId) && (layer.deleteElement(change.elementId), result.reverted++);
+        else if (change.type === "update" && change.before) {
+          const element = layer.getElement(change.elementId);
+          if (element) {
+            const elementData = change.before;
+            Object.assign(element, elementData), result.reverted++;
+          }
+        } else if (change.type === "delete" && change.before && !layer.listElements().some((e) => e.id === change.elementId)) {
+          const elementData = change.before, element = new Element({
+            id: change.elementId,
+            type: elementData.type || "unknown",
+            name: elementData.name || change.elementId,
+            description: elementData.description,
+            properties: elementData
+          });
+          layer.addElement(element), result.reverted++;
+        }
+      } catch (error) {
+        result.failed++, result.errors.push({
+          change,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return result.failed === 0 && (changeset.markReverted(), await this.save(changeset)), result;
+  }
+  /**
+   * Sanitize changeset name for use as filename
+   */
+  sanitizeName(name) {
+    return name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+  }
+}
+export {
+  Changeset,
+  ChangesetManager
+};
+//# sourceMappingURL=changeset.js.map

package/dist/core/changeset.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/changeset.ts"],
+  "sourcesContent": ["/**\n * Changeset - Represents a collection of model changes\n *\n * Changesets allow grouping related modifications to the architecture model\n * and applying/reverting them as a unit.\n */\n\nimport { readJSON, writeJSON, ensureDir, fileExists } from '../utils/file-io.js';\nimport type { Model } from './model.js';\nimport { Element } from './element.js';\n\n/**\n * Represents a single change in a changeset\n */\nexport interface Change {\n  type: 'add' | 'update' | 'delete';\n  elementId: string;\n  layerName: string;\n  before?: Record<string, unknown>;\n  after?: Record<string, unknown>;\n  timestamp: string;\n}\n\n/**\n * Changeset metadata\n */\nexport interface ChangesetData {\n  name: string;\n  description?: string;\n  created: string;\n  modified: string;\n  changes: Change[];\n  status: 'draft' | 'applied' | 'reverted';\n}\n\n/**\n * Changeset class for managing model changes\n */\nexport class Changeset {\n  name: string;\n  description?: string;\n  created: string;\n  modified: string;\n  changes: Change[] = [];\n  status: 'draft' | 'applied' | 'reverted' = 'draft';\n\n  constructor(data: ChangesetData) {\n    this.name = data.name;\n    this.description = data.description;\n    this.created = data.created;\n    this.modified = data.modified;\n    this.changes = data.changes || [];\n    this.status = data.status || 'draft';\n  }\n\n  /**\n   * Create a new changeset\n   */\n  static create(name: string, description?: string): Changeset {\n    const now = new Date().toISOString();\n    return new Changeset({\n      name,\n      description,\n      created: now,\n      modified: now,\n      changes: [],\n      status: 'draft',\n    });\n  }\n\n  /**\n   * Add a change to the changeset\n   */\n  addChange(\n    type: 'add' | 'update' | 'delete',\n    elementId: string,\n    layerName: string,\n    before?: Record<string, unknown>,\n    after?: Record<string, unknown>\n  ): void {\n    this.changes.push({\n      type,\n      elementId,\n      layerName,\n      before,\n      after,\n      timestamp: new Date().toISOString(),\n    });\n    this.updateModified();\n  }\n\n  /**\n   * Update the modified timestamp\n   */\n  updateModified(): void {\n    this.modified = new Date().toISOString();\n  }\n\n  /**\n   * Get number of changes\n   */\n  getChangeCount(): number {\n    return this.changes.length;\n  }\n\n  /**\n   * Get changes by type\n   */\n  getChangesByType(type: 'add' | 'update' | 'delete'): Change[] {\n    return this.changes.filter((c) => c.type === type);\n  }\n\n  /**\n   * Mark changeset as applied\n   */\n  markApplied(): void {\n    this.status = 'applied';\n    this.updateModified();\n  }\n\n  /**\n   * Mark changeset as reverted\n   */\n  markReverted(): void {\n    this.status = 'reverted';\n    this.updateModified();\n  }\n\n  /**\n   * Serialize to JSON\n   */\n  toJSON(): ChangesetData {\n    return {\n      name: this.name,\n      description: this.description,\n      created: this.created,\n      modified: this.modified,\n      changes: this.changes,\n      status: this.status,\n    };\n  }\n\n  /**\n   * Create from JSON data\n   */\n  static fromJSON(data: ChangesetData): Changeset {\n    return new Changeset(data);\n  }\n}\n\n/**\n * Changeset Manager for storing and retrieving changesets\n */\nexport class ChangesetManager {\n  private changesetsDir: string;\n\n  constructor(modelPath: string) {\n    this.changesetsDir = `${modelPath}/.dr/changesets`;\n  }\n\n  /**\n   * Create a new changeset\n   */\n  async create(name: string, description?: string): Promise<Changeset> {\n    const changeset = Changeset.create(name, description);\n    await this.save(changeset);\n    return changeset;\n  }\n\n  /**\n   * Save a changeset to disk\n   */\n  async save(changeset: Changeset): Promise<void> {\n    await ensureDir(this.changesetsDir);\n    const filePath = `${this.changesetsDir}/${this.sanitizeName(changeset.name)}.json`;\n    await writeJSON(filePath, changeset.toJSON(), true);\n  }\n\n  /**\n   * Load a changeset by name\n   */\n  async load(name: string): Promise<Changeset | null> {\n    const filePath = `${this.changesetsDir}/${this.sanitizeName(name)}.json`;\n\n    if (!(await fileExists(filePath))) {\n      return null;\n    }\n\n    const data = await readJSON<ChangesetData>(filePath);\n    return Changeset.fromJSON(data);\n  }\n\n  /**\n   * List all changesets\n   */\n  async list(): Promise<Changeset[]> {\n    if (!(await fileExists(this.changesetsDir))) {\n      return [];\n    }\n\n    const fs = await import('fs/promises');\n    const files = await fs.readdir(this.changesetsDir);\n    const changesets: Changeset[] = [];\n\n    for (const file of files) {\n      if (file.endsWith('.json')) {\n        const data = await readJSON<ChangesetData>(\n          `${this.changesetsDir}/${file}`\n        );\n        changesets.push(Changeset.fromJSON(data));\n      }\n    }\n\n    return changesets;\n  }\n\n  /**\n   * Delete a changeset\n   */\n  async delete(name: string): Promise<void> {\n    const filePath = `${this.changesetsDir}/${this.sanitizeName(name)}.json`;\n\n    if (!(await fileExists(filePath))) {\n      throw new Error(`Changeset '${name}' not found`);\n    }\n\n    const fs = await import('fs/promises');\n    await fs.unlink(filePath);\n  }\n\n  /**\n   * Apply a changeset to the model\n   */\n  async apply(model: Model, name: string): Promise<ApplyResult> {\n    const changeset = await this.load(name);\n\n    if (!changeset) {\n      throw new Error(`Changeset '${name}' not found`);\n    }\n\n    const result: ApplyResult = {\n      changeset: name,\n      applied: 0,\n      failed: 0,\n      errors: [],\n    };\n\n    for (const change of changeset.changes) {\n      try {\n        const layer = await model.getLayer(change.layerName);\n\n        if (!layer) {\n          throw new Error(`Layer '${change.layerName}' not found`);\n        }\n\n        if (change.type === 'add' && change.after) {\n          // Add element to layer\n          const elements = layer.listElements();\n          const elementExists = elements.some((e) => e.id === change.elementId);\n\n          if (!elementExists) {\n            // Create element based on after data\n            const elementData = change.after as Record<string, unknown>;\n            const element = new Element({\n              id: change.elementId,\n              type: (elementData.type as string) || 'unknown',\n              name: (elementData.name as string) || change.elementId,\n              description: elementData.description as string | undefined,\n              properties: elementData,\n            });\n            layer.addElement(element);\n            result.applied++;\n          }\n        } else if (change.type === 'update' && change.after) {\n          // Update element in layer\n          const element = layer.getElement(change.elementId);\n\n          if (element) {\n            const elementData = change.after as Record<string, unknown>;\n            Object.assign(element, elementData);\n            result.applied++;\n          }\n        } else if (change.type === 'delete') {\n          // Delete element from layer\n          const element = layer.getElement(change.elementId);\n\n          if (element) {\n            layer.deleteElement(change.elementId);\n            result.applied++;\n          }\n        }\n      } catch (error) {\n        result.failed++;\n        result.errors.push({\n          change,\n          error: error instanceof Error ? error.message : String(error),\n        });\n      }\n    }\n\n    if (result.failed === 0) {\n      changeset.markApplied();\n      await this.save(changeset);\n    }\n\n    return result;\n  }\n\n  /**\n   * Revert a changeset from the model\n   */\n  async revert(model: Model, name: string): Promise<RevertResult> {\n    const changeset = await this.load(name);\n\n    if (!changeset) {\n      throw new Error(`Changeset '${name}' not found`);\n    }\n\n    const result: RevertResult = {\n      changeset: name,\n      reverted: 0,\n      failed: 0,\n      errors: [],\n    };\n\n    // Process changes in reverse order\n    for (let i = changeset.changes.length - 1; i >= 0; i--) {\n      const change = changeset.changes[i];\n\n      try {\n        const layer = await model.getLayer(change.layerName);\n\n        if (!layer) {\n          throw new Error(`Layer '${change.layerName}' not found`);\n        }\n\n        // Reverse each operation\n        if (change.type === 'add') {\n          // Remove the element that was added\n          const element = layer.getElement(change.elementId);\n\n          if (element) {\n            layer.deleteElement(change.elementId);\n            result.reverted++;\n          }\n        } else if (change.type === 'update' && change.before) {\n          // Restore to previous state\n          const element = layer.getElement(change.elementId);\n\n          if (element) {\n            const elementData = change.before as Record<string, unknown>;\n            Object.assign(element, elementData);\n            result.reverted++;\n          }\n        } else if (change.type === 'delete' && change.before) {\n          // Recreate the deleted element\n          const elements = layer.listElements();\n          const elementExists = elements.some((e) => e.id === change.elementId);\n\n          if (!elementExists) {\n            const elementData = change.before as Record<string, unknown>;\n            const element = new Element({\n              id: change.elementId,\n              type: (elementData.type as string) || 'unknown',\n              name: (elementData.name as string) || change.elementId,\n              description: elementData.description as string | undefined,\n              properties: elementData,\n            });\n            layer.addElement(element);\n            result.reverted++;\n          }\n        }\n      } catch (error) {\n        result.failed++;\n        result.errors.push({\n          change,\n          error: error instanceof Error ? error.message : String(error),\n        });\n      }\n    }\n\n    if (result.failed === 0) {\n      changeset.markReverted();\n      await this.save(changeset);\n    }\n\n    return result;\n  }\n\n  /**\n   * Sanitize changeset name for use as filename\n   */\n  private sanitizeName(name: string): string {\n    return name\n      .toLowerCase()\n      .replace(/\\s+/g, '-')\n      .replace(/[^a-z0-9-]/g, '');\n  }\n}\n\n/**\n * Result of applying a changeset\n */\nexport interface ApplyResult {\n  changeset: string;\n  applied: number;\n  failed: number;\n  errors: Array<{\n    change: Change;\n    error: string;\n  }>;\n}\n\n/**\n * Result of reverting a changeset\n */\nexport interface RevertResult {\n  changeset: string;\n  reverted: number;\n  failed: number;\n  errors: Array<{\n    change: Change;\n    error: string;\n  }>;\n}\n"],
+  "mappings": "AAOA,SAAS,UAAU,WAAW,WAAW,kBAAkB;AAE3D,SAAS,eAAe;AA6BlB,MAAO,UAAS;EACpB;EACA;EACA;EACA;EACA,UAAoB,CAAA;EACpB,SAA2C;EAE3C,YAAY,MAAmB;AAC7B,SAAK,OAAO,KAAK,MACjB,KAAK,cAAc,KAAK,aACxB,KAAK,UAAU,KAAK,SACpB,KAAK,WAAW,KAAK,UACrB,KAAK,UAAU,KAAK,WAAW,CAAA,GAC/B,KAAK,SAAS,KAAK,UAAU;EAC/B;;;;EAKA,OAAO,OAAO,MAAc,aAAoB;AAC9C,UAAM,OAAM,oBAAI,KAAI,GAAG,YAAW;AAClC,WAAO,IAAI,UAAU;MACnB;MACA;MACA,SAAS;MACT,UAAU;MACV,SAAS,CAAA;MACT,QAAQ;KACT;EACH;;;;EAKA,UACE,MACA,WACA,WACA,QACA,OAA+B;AAE/B,SAAK,QAAQ,KAAK;MAChB;MACA;MACA;MACA;MACA;MACA,YAAW,oBAAI,KAAI,GAAG,YAAW;KAClC,GACD,KAAK,eAAc;EACrB;;;;EAKA,iBAAc;AACZ,SAAK,YAAW,oBAAI,KAAI,GAAG,YAAW;EACxC;;;;EAKA,iBAAc;AACZ,WAAO,KAAK,QAAQ;EACtB;;;;EAKA,iBAAiB,MAAiC;AAChD,WAAO,KAAK,QAAQ,OAAO,CAAC,MAAM,EAAE,SAAS,IAAI;EACnD;;;;EAKA,cAAW;AACT,SAAK,SAAS,WACd,KAAK,eAAc;EACrB;;;;EAKA,eAAY;AACV,SAAK,SAAS,YACd,KAAK,eAAc;EACrB;;;;EAKA,SAAM;AACJ,WAAO;MACL,MAAM,KAAK;MACX,aAAa,KAAK;MAClB,SAAS,KAAK;MACd,UAAU,KAAK;MACf,SAAS,KAAK;MACd,QAAQ,KAAK;;EAEjB;;;;EAKA,OAAO,SAAS,MAAmB;AACjC,WAAO,IAAI,UAAU,IAAI;EAC3B;;AAMI,MAAO,iBAAgB;EACnB;EAER,YAAY,WAAiB;AAC3B,SAAK,gBAAgB,GAAG,SAAS;EACnC;;;;EAKA,MAAM,OAAO,MAAc,aAAoB;AAC7C,UAAM,YAAY,UAAU,OAAO,MAAM,WAAW;AACpD,iBAAM,KAAK,KAAK,SAAS,GAClB;EACT;;;;EAKA,MAAM,KAAK,WAAoB;AAC7B,UAAM,UAAU,KAAK,aAAa;AAClC,UAAM,WAAW,GAAG,KAAK,aAAa,IAAI,KAAK,aAAa,UAAU,IAAI,CAAC;AAC3E,UAAM,UAAU,UAAU,UAAU,OAAM,GAAI,EAAI;EACpD;;;;EAKA,MAAM,KAAK,MAAY;AACrB,UAAM,WAAW,GAAG,KAAK,aAAa,IAAI,KAAK,aAAa,IAAI,CAAC;AAEjE,QAAI,CAAE,MAAM,WAAW,QAAQ;AAC7B,aAAO;AAGT,UAAM,OAAO,MAAM,SAAwB,QAAQ;AACnD,WAAO,UAAU,SAAS,IAAI;EAChC;;;;EAKA,MAAM,OAAI;AACR,QAAI,CAAE,MAAM,WAAW,KAAK,aAAa;AACvC,aAAO,CAAA;AAIT,UAAM,QAAQ,OADH,MAAM,OAAO,aAAa,GACd,QAAQ,KAAK,aAAa,GAC3C,aAA0B,CAAA;AAEhC,eAAW,QAAQ;AACjB,UAAI,KAAK,SAAS,OAAO,GAAG;AAC1B,cAAM,OAAO,MAAM,SACjB,GAAG,KAAK,aAAa,IAAI,IAAI,EAAE;AAEjC,mBAAW,KAAK,UAAU,SAAS,IAAI,CAAC;MAC1C;AAGF,WAAO;EACT;;;;EAKA,MAAM,OAAO,MAAY;AACvB,UAAM,WAAW,GAAG,KAAK,aAAa,IAAI,KAAK,aAAa,IAAI,CAAC;AAEjE,QAAI,CAAE,MAAM,WAAW,QAAQ;AAC7B,YAAM,IAAI,MAAM,cAAc,IAAI,aAAa;AAIjD,WADW,MAAM,OAAO,aAAa,GAC5B,OAAO,QAAQ;EAC1B;;;;EAKA,MAAM,MAAM,OAAc,MAAY;AACpC,UAAM,YAAY,MAAM,KAAK,KAAK,IAAI;AAEtC,QAAI,CAAC;AACH,YAAM,IAAI,MAAM,cAAc,IAAI,aAAa;AAGjD,UAAM,SAAsB;MAC1B,WAAW;MACX,SAAS;MACT,QAAQ;MACR,QAAQ,CAAA;;AAGV,eAAW,UAAU,UAAU;AAC7B,UAAI;AACF,cAAM,QAAQ,MAAM,MAAM,SAAS,OAAO,SAAS;AAEnD,YAAI,CAAC;AACH,gBAAM,IAAI,MAAM,UAAU,OAAO,SAAS,aAAa;AAGzD,YAAI,OAAO,SAAS,SAAS,OAAO;AAKlC,cAAI,CAHa,MAAM,aAAY,EACJ,KAAK,CAAC,MAAM,EAAE,OAAO,OAAO,SAAS,GAEhD;AAElB,kBAAM,cAAc,OAAO,OACrB,UAAU,IAAI,QAAQ;cAC1B,IAAI,OAAO;cACX,MAAO,YAAY,QAAmB;cACtC,MAAO,YAAY,QAAmB,OAAO;cAC7C,aAAa,YAAY;cACzB,YAAY;aACb;AACD,kBAAM,WAAW,OAAO,GACxB,OAAO;UACT;mBACS,OAAO,SAAS,YAAY,OAAO,OAAO;AAEnD,gBAAM,UAAU,MAAM,WAAW,OAAO,SAAS;AAEjD,cAAI,SAAS;AACX,kBAAM,cAAc,OAAO;AAC3B,mBAAO,OAAO,SAAS,WAAW,GAClC,OAAO;UACT;QACF,MAAO,CAAI,OAAO,SAAS,YAET,MAAM,WAAW,OAAO,SAAS,MAG/C,MAAM,cAAc,OAAO,SAAS,GACpC,OAAO;MAGb,SAAS,OAAO;AACd,eAAO,UACP,OAAO,OAAO,KAAK;UACjB;UACA,OAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;SAC7D;MACH;AAGF,WAAI,OAAO,WAAW,MACpB,UAAU,YAAW,GACrB,MAAM,KAAK,KAAK,SAAS,IAGpB;EACT;;;;EAKA,MAAM,OAAO,OAAc,MAAY;AACrC,UAAM,YAAY,MAAM,KAAK,KAAK,IAAI;AAEtC,QAAI,CAAC;AACH,YAAM,IAAI,MAAM,cAAc,IAAI,aAAa;AAGjD,UAAM,SAAuB;MAC3B,WAAW;MACX,UAAU;MACV,QAAQ;MACR,QAAQ,CAAA;;AAIV,aAAS,IAAI,UAAU,QAAQ,SAAS,GAAG,KAAK,GAAG,KAAK;AACtD,YAAM,SAAS,UAAU,QAAQ,CAAC;AAElC,UAAI;AACF,cAAM,QAAQ,MAAM,MAAM,SAAS,OAAO,SAAS;AAEnD,YAAI,CAAC;AACH,gBAAM,IAAI,MAAM,UAAU,OAAO,SAAS,aAAa;AAIzD,YAAI,OAAO,SAAS;AAIlB,UAFgB,MAAM,WAAW,OAAO,SAAS,MAG/C,MAAM,cAAc,OAAO,SAAS,GACpC,OAAO;iBAEA,OAAO,SAAS,YAAY,OAAO,QAAQ;AAEpD,gBAAM,UAAU,MAAM,WAAW,OAAO,SAAS;AAEjD,cAAI,SAAS;AACX,kBAAM,cAAc,OAAO;AAC3B,mBAAO,OAAO,SAAS,WAAW,GAClC,OAAO;UACT;QACF,WAAW,OAAO,SAAS,YAAY,OAAO,UAKxC,CAHa,MAAM,aAAY,EACJ,KAAK,CAAC,MAAM,EAAE,OAAO,OAAO,SAAS,GAEhD;AAClB,gBAAM,cAAc,OAAO,QACrB,UAAU,IAAI,QAAQ;YAC1B,IAAI,OAAO;YACX,MAAO,YAAY,QAAmB;YACtC,MAAO,YAAY,QAAmB,OAAO;YAC7C,aAAa,YAAY;YACzB,YAAY;WACb;AACD,gBAAM,WAAW,OAAO,GACxB,OAAO;QACT;MAEJ,SAAS,OAAO;AACd,eAAO,UACP,OAAO,OAAO,KAAK;UACjB;UACA,OAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;SAC7D;MACH;IACF;AAEA,WAAI,OAAO,WAAW,MACpB,UAAU,aAAY,GACtB,MAAM,KAAK,KAAK,SAAS,IAGpB;EACT;;;;EAKQ,aAAa,MAAY;AAC/B,WAAO,KACJ,YAAW,EACX,QAAQ,QAAQ,GAAG,EACnB,QAAQ,eAAe,EAAE;EAC9B;;",
+  "names": []
+}

package/dist/core/dependency-tracker.js

@@ -0,0 +1,322 @@
+import Graph from "graphology";
+var TraceDirection;
+(function(TraceDirection2) {
+  TraceDirection2.UP = "up", TraceDirection2.DOWN = "down", TraceDirection2.BOTH = "both";
+})(TraceDirection || (TraceDirection = {}));
+class DependencyTracker {
+  registry;
+  graph;
+  model;
+  constructor(registryOrGraph, model) {
+    registryOrGraph instanceof Graph ? this.graph = registryOrGraph : (this.registry = registryOrGraph, this.graph = registryOrGraph.getDependencyGraph()), this.model = model;
+  }
+  /**
+   * Get dependency graph
+   */
+  getGraph() {
+    return this.registry && (this.graph = this.registry.getDependencyGraph()), this.graph;
+  }
+  /**
+   * Trace dependencies from an element
+   *
+   * @param elementId - Element ID to start from
+   * @param direction - Direction to trace (up, down, both)
+   * @param maxDepth - Maximum depth to trace (null = unlimited)
+   * @returns Array of dependent element IDs
+   */
+  traceDependencies(elementId, direction = TraceDirection.BOTH, maxDepth = null) {
+    const graph = this.getGraph();
+    if (!graph.hasNode(elementId))
+      return [];
+    const dependencies = /* @__PURE__ */ new Set();
+    return (direction === TraceDirection.UP || direction === TraceDirection.BOTH) && this._traceUp(graph, elementId, maxDepth).forEach((id) => dependencies.add(id)), (direction === TraceDirection.DOWN || direction === TraceDirection.BOTH) && this._traceDown(graph, elementId, maxDepth).forEach((id) => dependencies.add(id)), Array.from(dependencies);
+  }
+  /**
+   * Trace upward dependencies (what element depends on - successors)
+   * Private helper matching Python CLI behavior
+   */
+  _traceUp(graph, elementId, maxDepth) {
+    return maxDepth === null ? this._getDescendants(graph, elementId) : this._getDescendantsLimited(graph, elementId, maxDepth);
+  }
+  /**
+   * Trace downward dependencies (what depends on element - predecessors)
+   * Private helper matching Python CLI behavior
+   */
+  _traceDown(graph, elementId, maxDepth) {
+    return maxDepth === null ? this._getAncestors(graph, elementId) : this._getAncestorsLimited(graph, elementId, maxDepth);
+  }
+  /**
+   * Get all descendants (reachable via outgoing edges) - DFS
+   * Equivalent to networkx.descendants()
+   */
+  _getDescendants(graph, startNode) {
+    const visited = /* @__PURE__ */ new Set(), stack = [startNode];
+    for (; stack.length > 0; ) {
+      const node = stack.pop();
+      if (graph.hasNode(node))
+        for (const neighbor of graph.outNeighbors(node))
+          visited.has(neighbor) || (visited.add(neighbor), stack.push(neighbor));
+    }
+    return visited;
+  }
+  /**
+   * Get ancestors (reachable via incoming edges) - DFS
+   * Equivalent to networkx.ancestors()
+   */
+  _getAncestors(graph, startNode) {
+    const visited = /* @__PURE__ */ new Set(), stack = [startNode];
+    for (; stack.length > 0; ) {
+      const node = stack.pop();
+      if (graph.hasNode(node))
+        for (const neighbor of graph.inNeighbors(node))
+          visited.has(neighbor) || (visited.add(neighbor), stack.push(neighbor));
+    }
+    return visited;
+  }
+  /**
+   * Get descendants within max_depth using BFS level-by-level
+   * Matches Python CLI behavior exactly
+   */
+  _getDescendantsLimited(graph, startNode, maxDepth) {
+    const descendants = /* @__PURE__ */ new Set();
+    let currentLevel = /* @__PURE__ */ new Set([startNode]);
+    for (let depth = 0; depth < maxDepth; depth++) {
+      const nextLevel = /* @__PURE__ */ new Set();
+      for (const node of currentLevel)
+        if (graph.hasNode(node))
+          for (const neighbor of graph.outNeighbors(node))
+            nextLevel.add(neighbor);
+      if (nextLevel.forEach((id) => descendants.add(id)), currentLevel = nextLevel, currentLevel.size === 0)
+        break;
+    }
+    return descendants;
+  }
+  /**
+   * Get ancestors within max_depth using BFS level-by-level
+   * Matches Python CLI behavior exactly
+   */
+  _getAncestorsLimited(graph, startNode, maxDepth) {
+    const ancestors = /* @__PURE__ */ new Set();
+    let currentLevel = /* @__PURE__ */ new Set([startNode]);
+    for (let depth = 0; depth < maxDepth; depth++) {
+      const nextLevel = /* @__PURE__ */ new Set();
+      for (const node of currentLevel)
+        if (graph.hasNode(node))
+          for (const neighbor of graph.inNeighbors(node))
+            nextLevel.add(neighbor);
+      if (nextLevel.forEach((id) => ancestors.add(id)), currentLevel = nextLevel, currentLevel.size === 0)
+        break;
+    }
+    return ancestors;
+  }
+  /**
+   * Find all dependency paths between two elements
+   *
+   * @param sourceId - Source element ID
+   * @param targetId - Target element ID
+   * @param maxPaths - Maximum number of paths to return
+   * @returns Array of dependency paths
+   */
+  findDependencyPaths(sourceId, targetId, maxPaths = 10) {
+    const graph = this.getGraph();
+    return !graph.hasNode(sourceId) || !graph.hasNode(targetId) ? [] : this._findAllSimplePaths(graph, sourceId, targetId, maxPaths).map((path) => {
+      const relationshipTypes = [];
+      for (let i = 0; i < path.length - 1; i++) {
+        const edgeAttrs = graph.getEdgeAttributes(path[i], path[i + 1]);
+        relationshipTypes.push(edgeAttrs?.type || "unknown");
+      }
+      return {
+        source: sourceId,
+        target: targetId,
+        path,
+        depth: path.length - 1,
+        relationship_types: relationshipTypes
+      };
+    });
+  }
+  /**
+   * Find all simple paths between source and target
+   * Implements DFS path-finding similar to networkx.all_simple_paths
+   */
+  _findAllSimplePaths(graph, source, target, maxPaths) {
+    const paths = [], visited = /* @__PURE__ */ new Set(), dfs = (current, path) => {
+      if (!(paths.length >= maxPaths)) {
+        if (current === target) {
+          paths.push([...path, current]);
+          return;
+        }
+        if (visited.add(current), path.push(current), graph.hasNode(current))
+          for (const neighbor of graph.outNeighbors(current))
+            visited.has(neighbor) || dfs(neighbor, path);
+        path.pop(), visited.delete(current);
+      }
+    };
+    return dfs(source, []), paths;
+  }
+  /**
+   * Find hub elements (elements with many connections)
+   *
+   * @param threshold - Minimum number of connections to be considered a hub
+   * @returns Array of [elementId, connectionCount] tuples, sorted by count descending
+   */
+  getHubElements(threshold = 10) {
+    const graph = this.getGraph(), hubs = [];
+    for (const node of graph.nodes()) {
+      const degree = graph.degree(node);
+      degree >= threshold && hubs.push([node, degree]);
+    }
+    return hubs.sort((a, b) => b[1] - a[1]), hubs;
+  }
+  /**
+   * Get direct dependents (incoming edges)
+   */
+  getDependents(elementId) {
+    const graph = this.getGraph();
+    return graph.hasNode(elementId) ? graph.inNeighbors(elementId) : [];
+  }
+  /**
+   * Get direct dependencies (outgoing edges)
+   */
+  getDependencies(elementId) {
+    const graph = this.getGraph();
+    return graph.hasNode(elementId) ? graph.outNeighbors(elementId) : [];
+  }
+  /**
+   * Get all elements that transitively depend on the given element (ancestors)
+   */
+  getTransitiveDependents(elementId) {
+    const graph = this.getGraph();
+    return graph.hasNode(elementId) ? Array.from(this._getAncestors(graph, elementId)) : [];
+  }
+  /**
+   * Get all elements this element transitively depends on (descendants)
+   */
+  getTransitiveDependencies(elementId) {
+    const graph = this.getGraph();
+    return graph.hasNode(elementId) ? Array.from(this._getDescendants(graph, elementId)) : [];
+  }
+  /**
+   * Detect cycles in the dependency graph
+   */
+  detectCycles() {
+    const graph = this.getGraph(), visited = /* @__PURE__ */ new Set(), stack = /* @__PURE__ */ new Set(), path = [], cycleMap = /* @__PURE__ */ new Map(), canonicalKey = (cycle) => {
+      const unique = Array.from(new Set(cycle));
+      return unique.sort(), unique.join("|");
+    }, dfs = (node) => {
+      visited.add(node), stack.add(node), path.push(node);
+      for (const neighbor of graph.outNeighbors(node))
+        if (!visited.has(neighbor))
+          dfs(neighbor);
+        else if (stack.has(neighbor)) {
+          const idx = path.indexOf(neighbor);
+          if (idx !== -1) {
+            const cycle = path.slice(idx), key = canonicalKey(cycle);
+            cycleMap.has(key) || cycleMap.set(key, [...cycle]);
+          }
+        }
+      stack.delete(node), path.pop();
+    };
+    for (const node of graph.nodes())
+      visited.has(node) || dfs(node);
+    return Array.from(cycleMap.values());
+  }
+  /**
+   * Calculate basic graph metrics
+   */
+  getMetrics() {
+    const graph = this.getGraph(), nodeCount = graph.order, edgeCount = graph.size, cycleCount = this.detectCycles().length, visited = /* @__PURE__ */ new Set();
+    let connectedComponents = 0;
+    const bfs = (start) => {
+      const queue = [start];
+      for (visited.add(start); queue.length > 0; ) {
+        const node = queue.shift(), neighbors = /* @__PURE__ */ new Set([
+          ...graph.outNeighbors(node),
+          ...graph.inNeighbors(node)
+        ]);
+        for (const neighbor of neighbors)
+          visited.has(neighbor) || (visited.add(neighbor), queue.push(neighbor));
+      }
+    };
+    for (const node of graph.nodes())
+      visited.has(node) || (connectedComponents += 1, bfs(node));
+    return { nodeCount, edgeCount, cycleCount, connectedComponents };
+  }
+  /**
+   * Find elements with no incoming edges
+   */
+  findSourceElements() {
+    const graph = this.getGraph(), sources = [];
+    for (const node of graph.nodes())
+      graph.inNeighbors(node).length === 0 && sources.push(node);
+    return sources;
+  }
+  /**
+   * Find elements with no outgoing edges
+   */
+  findSinkElements() {
+    const graph = this.getGraph(), sinks = [];
+    for (const node of graph.nodes())
+      graph.outNeighbors(node).length === 0 && sinks.push(node);
+    return sinks;
+  }
+  /**
+   * Calculate how many elements would be impacted if this element changed
+   * (all ancestors/predecessors excluding the element itself)
+   */
+  getImpactRadius(elementId) {
+    const graph = this.getGraph();
+    return graph.hasNode(elementId) ? this._getAncestors(graph, elementId).size : 0;
+  }
+  /**
+   * Get longest dependency chain depth from this element (outgoing edges)
+   */
+  getDependencyDepth(elementId) {
+    const graph = this.getGraph();
+    if (!graph.hasNode(elementId))
+      return -1;
+    const memo = /* @__PURE__ */ new Map(), stack = /* @__PURE__ */ new Set(), dfsDepth = (node) => {
+      if (memo.has(node))
+        return memo.get(node);
+      if (stack.has(node))
+        return 0;
+      stack.add(node);
+      let maxDepth = 0;
+      for (const neighbor of graph.outNeighbors(node)) {
+        const neighborDepth = dfsDepth(neighbor);
+        maxDepth = Math.max(maxDepth, 1 + neighborDepth);
+      }
+      return stack.delete(node), memo.set(node, maxDepth), maxDepth;
+    };
+    return dfsDepth(elementId);
+  }
+  /**
+   * Group dependencies by layer (requires model)
+   */
+  getDependencyLayers(elementId) {
+    if (!this.model)
+      return {};
+    const byLayer = {}, dependencies = this.traceDependencies(elementId, TraceDirection.BOTH);
+    for (const depId of dependencies) {
+      const element = this.model.getElementById(depId);
+      !element || !element.layer || (byLayer[element.layer] || (byLayer[element.layer] = []), byLayer[element.layer].push(depId));
+    }
+    return byLayer;
+  }
+  /**
+   * Find elements with no references (requires model)
+   */
+  getOrphanedElements() {
+    if (!this.model)
+      return [];
+    const graph = this.getGraph(), orphaned = [];
+    for (const layer of this.model.layers.values())
+      for (const element of layer.elements.values())
+        graph.hasNode(element.id) ? graph.degree(element.id) === 0 && orphaned.push(element) : orphaned.push(element);
+    return orphaned;
+  }
+}
+export {
+  DependencyTracker,
+  TraceDirection
+};
+//# sourceMappingURL=dependency-tracker.js.map

package/dist/core/dependency-tracker.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/dependency-tracker.ts"],
+  "sourcesContent": ["import Graph from 'graphology';\nimport { ReferenceRegistry } from './reference-registry.js';\nimport { Model } from './model.js';\n\n/**\n * Direction to trace dependencies (matches Python CLI TraceDirection enum)\n */\nexport enum TraceDirection {\n  UP = 'up',     // Find what this depends on (successors/descendants)\n  DOWN = 'down', // Find what depends on this (predecessors/ancestors)\n  BOTH = 'both'  // Both directions\n}\n\n/**\n * Represents a dependency path between two elements\n */\nexport interface DependencyPath {\n  source: string;\n  target: string;\n  path: string[];\n  depth: number;\n  relationship_types: string[];\n}\n\n/**\n * Dependency tracker - analyzes dependencies between elements\n *\n * Uses reference registry and graph algorithms to provide\n * dependency analysis and impact assessment.\n *\n * Matches Python CLI behavior from dependency_tracker.py\n */\nexport class DependencyTracker {\n  private registry?: ReferenceRegistry;\n  private graph: Graph;\n  private model?: Model;\n\n  constructor(registryOrGraph: ReferenceRegistry | Graph, model?: Model) {\n    if (registryOrGraph instanceof Graph) {\n      this.graph = registryOrGraph;\n    } else {\n      this.registry = registryOrGraph;\n      this.graph = registryOrGraph.getDependencyGraph();\n    }\n    this.model = model;\n  }\n\n  /**\n   * Get dependency graph\n   */\n  private getGraph(): Graph {\n    if (this.registry) {\n      // Rebuild from registry each time to reflect new references\n      this.graph = this.registry.getDependencyGraph();\n    }\n    return this.graph;\n  }\n\n  /**\n   * Trace dependencies from an element\n   *\n   * @param elementId - Element ID to start from\n   * @param direction - Direction to trace (up, down, both)\n   * @param maxDepth - Maximum depth to trace (null = unlimited)\n   * @returns Array of dependent element IDs\n   */\n  traceDependencies(\n    elementId: string,\n    direction: TraceDirection = TraceDirection.BOTH,\n    maxDepth: number | null = null\n  ): string[] {\n    const graph = this.getGraph();\n\n    if (!graph.hasNode(elementId)) {\n      return [];\n    }\n\n    const dependencies = new Set<string>();\n\n    // Trace upward (what this element depends on - successors)\n    if (direction === TraceDirection.UP || direction === TraceDirection.BOTH) {\n      const upDeps = this._traceUp(graph, elementId, maxDepth);\n      upDeps.forEach(id => dependencies.add(id));\n    }\n\n    // Trace downward (what depends on this element - predecessors)\n    if (direction === TraceDirection.DOWN || direction === TraceDirection.BOTH) {\n      const downDeps = this._traceDown(graph, elementId, maxDepth);\n      downDeps.forEach(id => dependencies.add(id));\n    }\n\n    return Array.from(dependencies);\n  }\n\n  /**\n   * Trace upward dependencies (what element depends on - successors)\n   * Private helper matching Python CLI behavior\n   */\n  private _traceUp(graph: Graph, elementId: string, maxDepth: number | null): Set<string> {\n    if (maxDepth === null) {\n      // Get all descendants (unlimited depth)\n      return this._getDescendants(graph, elementId);\n    } else {\n      // Get descendants within depth using BFS\n      return this._getDescendantsLimited(graph, elementId, maxDepth);\n    }\n  }\n\n  /**\n   * Trace downward dependencies (what depends on element - predecessors)\n   * Private helper matching Python CLI behavior\n   */\n  private _traceDown(graph: Graph, elementId: string, maxDepth: number | null): Set<string> {\n    if (maxDepth === null) {\n      // Get all ancestors (unlimited depth)\n      return this._getAncestors(graph, elementId);\n    } else {\n      // Get ancestors within depth using BFS\n      return this._getAncestorsLimited(graph, elementId, maxDepth);\n    }\n  }\n\n  /**\n   * Get all descendants (reachable via outgoing edges) - DFS\n   * Equivalent to networkx.descendants()\n   */\n  private _getDescendants(graph: Graph, startNode: string): Set<string> {\n    const visited = new Set<string>();\n    const stack = [startNode];\n\n    while (stack.length > 0) {\n      const node = stack.pop()!;\n\n      if (!graph.hasNode(node)) continue;\n\n      for (const neighbor of graph.outNeighbors(node)) {\n        if (!visited.has(neighbor)) {\n          visited.add(neighbor);\n          stack.push(neighbor);\n        }\n      }\n    }\n\n    return visited;\n  }\n\n  /**\n   * Get ancestors (reachable via incoming edges) - DFS\n   * Equivalent to networkx.ancestors()\n   */\n  private _getAncestors(graph: Graph, startNode: string): Set<string> {\n    const visited = new Set<string>();\n    const stack = [startNode];\n\n    while (stack.length > 0) {\n      const node = stack.pop()!;\n\n      if (!graph.hasNode(node)) continue;\n\n      for (const neighbor of graph.inNeighbors(node)) {\n        if (!visited.has(neighbor)) {\n          visited.add(neighbor);\n          stack.push(neighbor);\n        }\n      }\n    }\n\n    return visited;\n  }\n\n  /**\n   * Get descendants within max_depth using BFS level-by-level\n   * Matches Python CLI behavior exactly\n   */\n  private _getDescendantsLimited(graph: Graph, startNode: string, maxDepth: number): Set<string> {\n    const descendants = new Set<string>();\n    let currentLevel = new Set([startNode]);\n\n    for (let depth = 0; depth < maxDepth; depth++) {\n      const nextLevel = new Set<string>();\n\n      for (const node of currentLevel) {\n        if (!graph.hasNode(node)) continue;\n\n        for (const neighbor of graph.outNeighbors(node)) {\n          nextLevel.add(neighbor);\n        }\n      }\n\n      nextLevel.forEach(id => descendants.add(id));\n      currentLevel = nextLevel;\n\n      if (currentLevel.size === 0) {\n        break;\n      }\n    }\n\n    return descendants;\n  }\n\n  /**\n   * Get ancestors within max_depth using BFS level-by-level\n   * Matches Python CLI behavior exactly\n   */\n  private _getAncestorsLimited(graph: Graph, startNode: string, maxDepth: number): Set<string> {\n    const ancestors = new Set<string>();\n    let currentLevel = new Set([startNode]);\n\n    for (let depth = 0; depth < maxDepth; depth++) {\n      const nextLevel = new Set<string>();\n\n      for (const node of currentLevel) {\n        if (!graph.hasNode(node)) continue;\n\n        for (const neighbor of graph.inNeighbors(node)) {\n          nextLevel.add(neighbor);\n        }\n      }\n\n      nextLevel.forEach(id => ancestors.add(id));\n      currentLevel = nextLevel;\n\n      if (currentLevel.size === 0) {\n        break;\n      }\n    }\n\n    return ancestors;\n  }\n\n  /**\n   * Find all dependency paths between two elements\n   *\n   * @param sourceId - Source element ID\n   * @param targetId - Target element ID\n   * @param maxPaths - Maximum number of paths to return\n   * @returns Array of dependency paths\n   */\n  findDependencyPaths(\n    sourceId: string,\n    targetId: string,\n    maxPaths: number = 10\n  ): DependencyPath[] {\n    const graph = this.getGraph();\n\n    if (!graph.hasNode(sourceId) || !graph.hasNode(targetId)) {\n      return [];\n    }\n\n    // Find all simple paths (no cycles)\n    const paths = this._findAllSimplePaths(graph, sourceId, targetId, maxPaths);\n\n    // Convert to DependencyPath objects\n    return paths.map(path => {\n      // Get relationship types along path\n      const relationshipTypes: string[] = [];\n      for (let i = 0; i < path.length - 1; i++) {\n        const edgeAttrs = graph.getEdgeAttributes(path[i], path[i + 1]);\n        relationshipTypes.push(edgeAttrs?.type || 'unknown');\n      }\n\n      return {\n        source: sourceId,\n        target: targetId,\n        path,\n        depth: path.length - 1,\n        relationship_types: relationshipTypes\n      };\n    });\n  }\n\n  /**\n   * Find all simple paths between source and target\n   * Implements DFS path-finding similar to networkx.all_simple_paths\n   */\n  private _findAllSimplePaths(\n    graph: Graph,\n    source: string,\n    target: string,\n    maxPaths: number\n  ): string[][] {\n    const paths: string[][] = [];\n    const visited = new Set<string>();\n\n    const dfs = (current: string, path: string[]) => {\n      if (paths.length >= maxPaths) {\n        return;\n      }\n\n      if (current === target) {\n        paths.push([...path, current]);\n        return;\n      }\n\n      visited.add(current);\n      path.push(current);\n\n      if (graph.hasNode(current)) {\n        for (const neighbor of graph.outNeighbors(current)) {\n          if (!visited.has(neighbor)) {\n            dfs(neighbor, path);\n          }\n        }\n      }\n\n      path.pop();\n      visited.delete(current);\n    };\n\n    dfs(source, []);\n    return paths;\n  }\n\n  /**\n   * Find hub elements (elements with many connections)\n   *\n   * @param threshold - Minimum number of connections to be considered a hub\n   * @returns Array of [elementId, connectionCount] tuples, sorted by count descending\n   */\n  getHubElements(threshold: number = 10): [string, number][] {\n    const graph = this.getGraph();\n    const hubs: [string, number][] = [];\n\n    for (const node of graph.nodes()) {\n      const degree = graph.degree(node);\n      if (degree >= threshold) {\n        hubs.push([node, degree]);\n      }\n    }\n\n    // Sort by degree descending\n    hubs.sort((a, b) => b[1] - a[1]);\n\n    return hubs;\n  }\n\n  /**\n   * Get direct dependents (incoming edges)\n   */\n  getDependents(elementId: string): string[] {\n    const graph = this.getGraph();\n    if (!graph.hasNode(elementId)) return [];\n    return graph.inNeighbors(elementId);\n  }\n\n  /**\n   * Get direct dependencies (outgoing edges)\n   */\n  getDependencies(elementId: string): string[] {\n    const graph = this.getGraph();\n    if (!graph.hasNode(elementId)) return [];\n    return graph.outNeighbors(elementId);\n  }\n\n  /**\n   * Get all elements that transitively depend on the given element (ancestors)\n   */\n  getTransitiveDependents(elementId: string): string[] {\n    const graph = this.getGraph();\n    if (!graph.hasNode(elementId)) return [];\n    return Array.from(this._getAncestors(graph, elementId));\n  }\n\n  /**\n   * Get all elements this element transitively depends on (descendants)\n   */\n  getTransitiveDependencies(elementId: string): string[] {\n    const graph = this.getGraph();\n    if (!graph.hasNode(elementId)) return [];\n    return Array.from(this._getDescendants(graph, elementId));\n  }\n\n  /**\n   * Detect cycles in the dependency graph\n   */\n  detectCycles(): string[][] {\n    const graph = this.getGraph();\n    const visited = new Set<string>();\n    const stack = new Set<string>();\n    const path: string[] = [];\n    const cycleMap = new Map<string, string[]>();\n\n    const canonicalKey = (cycle: string[]): string => {\n      // Normalize cycle representation to avoid duplicates\n      const unique = Array.from(new Set(cycle));\n      unique.sort();\n      return unique.join('|');\n    };\n\n    const dfs = (node: string) => {\n      visited.add(node);\n      stack.add(node);\n      path.push(node);\n\n      for (const neighbor of graph.outNeighbors(node)) {\n        if (!visited.has(neighbor)) {\n          dfs(neighbor);\n        } else if (stack.has(neighbor)) {\n          // Found a cycle, capture the slice from neighbor to current\n          const idx = path.indexOf(neighbor);\n          if (idx !== -1) {\n            const cycle = path.slice(idx);\n            const key = canonicalKey(cycle);\n            if (!cycleMap.has(key)) {\n              cycleMap.set(key, [...cycle]);\n            }\n          }\n        }\n      }\n\n      stack.delete(node);\n      path.pop();\n    };\n\n    for (const node of graph.nodes()) {\n      if (!visited.has(node)) {\n        dfs(node);\n      }\n    }\n\n    return Array.from(cycleMap.values());\n  }\n\n  /**\n   * Calculate basic graph metrics\n   */\n  getMetrics(): { nodeCount: number; edgeCount: number; cycleCount: number; connectedComponents: number } {\n    const graph = this.getGraph();\n\n    const nodeCount = graph.order;\n    const edgeCount = graph.size;\n    const cycleCount = this.detectCycles().length;\n\n    // Count weakly connected components\n    const visited = new Set<string>();\n    let connectedComponents = 0;\n\n    const bfs = (start: string) => {\n      const queue = [start];\n      visited.add(start);\n\n      while (queue.length > 0) {\n        const node = queue.shift()!;\n        const neighbors = new Set<string>([\n          ...graph.outNeighbors(node),\n          ...graph.inNeighbors(node)\n        ]);\n\n        for (const neighbor of neighbors) {\n          if (!visited.has(neighbor)) {\n            visited.add(neighbor);\n            queue.push(neighbor);\n          }\n        }\n      }\n    };\n\n    for (const node of graph.nodes()) {\n      if (!visited.has(node)) {\n        connectedComponents += 1;\n        bfs(node);\n      }\n    }\n\n    return { nodeCount, edgeCount, cycleCount, connectedComponents };\n  }\n\n  /**\n   * Find elements with no incoming edges\n   */\n  findSourceElements(): string[] {\n    const graph = this.getGraph();\n    const sources: string[] = [];\n\n    for (const node of graph.nodes()) {\n      if (graph.inNeighbors(node).length === 0) {\n        sources.push(node);\n      }\n    }\n\n    return sources;\n  }\n\n  /**\n   * Find elements with no outgoing edges\n   */\n  findSinkElements(): string[] {\n    const graph = this.getGraph();\n    const sinks: string[] = [];\n\n    for (const node of graph.nodes()) {\n      if (graph.outNeighbors(node).length === 0) {\n        sinks.push(node);\n      }\n    }\n\n    return sinks;\n  }\n\n  /**\n   * Calculate how many elements would be impacted if this element changed\n   * (all ancestors/predecessors excluding the element itself)\n   */\n  getImpactRadius(elementId: string): number {\n    const graph = this.getGraph();\n    if (!graph.hasNode(elementId)) return 0;\n    const impacted = this._getAncestors(graph, elementId);\n    return impacted.size;\n  }\n\n  /**\n   * Get longest dependency chain depth from this element (outgoing edges)\n   */\n  getDependencyDepth(elementId: string): number {\n    const graph = this.getGraph();\n    if (!graph.hasNode(elementId)) return -1;\n\n    const memo = new Map<string, number>();\n    const stack = new Set<string>();\n\n    const dfsDepth = (node: string): number => {\n      if (memo.has(node)) return memo.get(node)!;\n      if (stack.has(node)) return 0; // break cycles\n\n      stack.add(node);\n      let maxDepth = 0;\n\n      for (const neighbor of graph.outNeighbors(node)) {\n        const neighborDepth = dfsDepth(neighbor);\n        maxDepth = Math.max(maxDepth, 1 + neighborDepth);\n      }\n\n      stack.delete(node);\n      memo.set(node, maxDepth);\n      return maxDepth;\n    };\n\n    return dfsDepth(elementId);\n  }\n\n  /**\n   * Group dependencies by layer (requires model)\n   */\n  getDependencyLayers(elementId: string): Record<string, string[]> {\n    if (!this.model) return {};\n\n    const byLayer: Record<string, string[]> = {};\n    const dependencies = this.traceDependencies(elementId, TraceDirection.BOTH);\n\n    for (const depId of dependencies) {\n      const element = this.model.getElementById(depId);\n      if (!element || !element.layer) continue;\n\n      if (!byLayer[element.layer]) {\n        byLayer[element.layer] = [];\n      }\n      byLayer[element.layer].push(depId);\n    }\n\n    return byLayer;\n  }\n\n  /**\n   * Find elements with no references (requires model)\n   */\n  getOrphanedElements(): any[] {\n    if (!this.model) return [];\n\n    const graph = this.getGraph();\n    const orphaned: any[] = [];\n\n    for (const layer of this.model.layers.values()) {\n      for (const element of layer.elements.values()) {\n        if (!graph.hasNode(element.id)) {\n          orphaned.push(element);\n        } else if (graph.degree(element.id) === 0) {\n          orphaned.push(element);\n        }\n      }\n    }\n\n    return orphaned;\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["TraceDirection"]
+}