@documentation-robotics/cli 0.1.13 → 0.2.0

package/dist/core/farm-sync-engine.js

@@ -0,0 +1,346 @@
+import path from "path";
+import { execSync, execFileSync } from "child_process";
+import { fileExists, ensureDir } from "../utils/file-io.js";
+import { FarmSyncState } from "./farm-sync-state.js";
+import { StagingAreaManager } from "./staging-area.js";
+import { getErrorMessage } from "../utils/errors.js";
+class FarmSyncEngine {
+  farmRoot;
+  model;
+  constructor(farmRoot, model) {
+    this.farmRoot = farmRoot, this.model = model || null;
+  }
+  /**
+   * Pull latest changes from remote for a codebase
+   * @param codebasePath - Relative path to codebase folder
+   * @returns Updated commit SHA
+   */
+  async pullCodebase(codebasePath) {
+    const fullPath = path.join(this.farmRoot, codebasePath);
+    if (!await fileExists(fullPath))
+      throw new Error(`Codebase directory not found: ${codebasePath}`);
+    try {
+      try {
+        execSync("git fetch --prune", { cwd: fullPath, stdio: "pipe" });
+      } catch (fetchError) {
+        const fetchMsg = getErrorMessage(fetchError);
+        if (!(fetchMsg.includes("No remote repository specified") || fetchMsg.includes("no remote")))
+          throw new Error(`git fetch failed: ${fetchMsg}`);
+      }
+      try {
+        execSync("git pull --no-rebase", { cwd: fullPath, stdio: "pipe" });
+      } catch (pullError) {
+        const pullMsg = getErrorMessage(pullError);
+        if (!(pullMsg.includes("No remote repository specified") || pullMsg.includes("no remote") || pullMsg.includes("no tracking information")))
+          throw new Error(`git pull failed: ${pullMsg}`);
+      }
+      return execSync("git rev-parse HEAD", { cwd: fullPath, encoding: "utf-8" }).trim();
+    } catch (error) {
+      throw new Error(`Failed to pull codebase '${codebasePath}': ${getErrorMessage(error)}`);
+    }
+  }
+  /**
+   * Get the current HEAD commit SHA for a codebase
+   */
+  async getCurrentCommit(codebasePath) {
+    const fullPath = path.join(this.farmRoot, codebasePath);
+    if (!await fileExists(fullPath))
+      throw new Error(`Codebase directory not found: ${codebasePath}`);
+    try {
+      return execSync("git rev-parse HEAD", { cwd: fullPath, encoding: "utf-8" }).trim();
+    } catch (error) {
+      throw new Error(`Failed to get current commit for '${codebasePath}': ${getErrorMessage(error)}`);
+    }
+  }
+  /**
+   * Compute diff between two commits
+   * Commit SHAs are validated before use to prevent command injection
+   */
+  async computeDiff(codebasePath, fromCommit, toCommit) {
+    const fullPath = path.join(this.farmRoot, codebasePath);
+    if (!await fileExists(fullPath))
+      throw new Error(`Codebase directory not found: ${codebasePath}`);
+    const commitShaRegex = /^[0-9a-f]{7,40}$/i;
+    if (!commitShaRegex.test(fromCommit) || !commitShaRegex.test(toCommit))
+      throw new Error(`Invalid commit SHA format. Expected 7-40 character hex string. Got: ${fromCommit}, ${toCommit}`);
+    try {
+      const diffOutput = execFileSync("git", ["diff", "--name-status", `${fromCommit}...${toCommit}`], {
+        cwd: fullPath,
+        encoding: "utf-8"
+      }), added = [], modified = [], deleted = [];
+      for (const line of diffOutput.trim().split(`
+`)) {
+        if (!line)
+          continue;
+        const [status, ...fileParts] = line.split("	"), filePath = fileParts.join("	");
+        switch (status) {
+          case "A":
+            added.push(filePath);
+            break;
+          case "M":
+            modified.push(filePath);
+            break;
+          case "D":
+            deleted.push(filePath);
+            break;
+          default:
+            if (status.startsWith("R")) {
+              const [oldPath, newPath] = fileParts;
+              deleted.push(oldPath), added.push(newPath);
+            } else status.startsWith("C") && added.push(fileParts[1]);
+            break;
+        }
+      }
+      return { added, modified, deleted };
+    } catch (error) {
+      throw new Error(`Failed to compute diff for '${codebasePath}': ${getErrorMessage(error)}`);
+    }
+  }
+  /**
+   * Map changed files to model elements using source references
+   * Looks at each model element's source references and matches against changed files
+   * Returns empty results if model is not available
+   */
+  async mapFilesToElements() {
+    if (!this.model)
+      return { confident: [], ambiguous: [] };
+    const confident = /* @__PURE__ */ new Map(), ambiguous = /* @__PURE__ */ new Map();
+    for (const layer of this.model.layers.values())
+      for (const element of layer.listElements()) {
+        if (!element.source_reference)
+          continue;
+        const sourceRef = element.source_reference;
+        if (!(!sourceRef.locations || sourceRef.locations.length === 0))
+          for (const location of sourceRef.locations) {
+            const filePath = location.file;
+            if (!confident.has(filePath) && !ambiguous.has(filePath)) {
+              const mapping = {
+                filePath,
+                possibleElements: [
+                  {
+                    elementId: element.id,
+                    layer: layer.name,
+                    confidence: 100,
+                    // Exact match from source reference
+                    sourceRef: location
+                  }
+                ]
+              };
+              confident.set(filePath, mapping);
+            } else if (confident.has(filePath)) {
+              const existing = confident.get(filePath);
+              confident.delete(filePath), existing.possibleElements.push({
+                elementId: element.id,
+                layer: layer.name,
+                confidence: 100,
+                sourceRef: location
+              }), ambiguous.set(filePath, existing);
+            } else
+              ambiguous.get(filePath).possibleElements.push({
+                elementId: element.id,
+                layer: layer.name,
+                confidence: 100,
+                sourceRef: location
+              });
+          }
+      }
+    return {
+      confident: Array.from(confident.values()),
+      ambiguous: Array.from(ambiguous.values())
+    };
+  }
+  /**
+   * Generate a changeset from file-to-element mappings
+   * Creates add/update/delete changes based on the diff and mappings
+   * Stages changes into the changeset for review before commit
+   */
+  async generateChangeset(project, diff, mappings, options = {}) {
+    if (!this.model)
+      throw new Error("Model is required for changeset generation");
+    const projectModelPath = path.join(this.farmRoot, project.model), stagingManager = new StagingAreaManager(projectModelPath, this.model), changesetName = `farm-sync-${project.name}-${Date.now()}`, changeset = await stagingManager.create(changesetName, `Auto-generated from farm sync of ${project.name}`);
+    if (!changeset.id)
+      throw new Error("Failed to create changeset - no ID assigned");
+    const warnings = [];
+    let changeCount = 0;
+    const confidentMap = new Map(mappings.confident.map((m) => [m.filePath, m]));
+    for (const filePath of diff.added) {
+      const mapping = confidentMap.get(filePath);
+      if (mapping && mapping.possibleElements.length === 1) {
+        const element = mapping.possibleElements[0];
+        await stagingManager.stage(changeset.id, {
+          type: "add",
+          elementId: element.elementId,
+          layerName: element.layer,
+          after: {
+            sourceFile: filePath,
+            syncSource: "codebase",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }), warnings.push(`File added: ${filePath} -> ${element.elementId} (staged for review, verify content accuracy)`), changeCount++;
+      }
+    }
+    for (const filePath of diff.modified) {
+      const mapping = confidentMap.get(filePath);
+      if (mapping && mapping.possibleElements.length === 1) {
+        const element = mapping.possibleElements[0];
+        await stagingManager.stage(changeset.id, {
+          type: "update",
+          elementId: element.elementId,
+          layerName: element.layer,
+          before: {
+            sourceFile: filePath,
+            syncSource: "codebase"
+          },
+          after: {
+            sourceFile: filePath,
+            syncSource: "codebase",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }), warnings.push(`File modified: ${filePath} -> ${element.elementId} (staged for review)`), changeCount++;
+      }
+    }
+    for (const filePath of diff.deleted) {
+      const mapping = confidentMap.get(filePath);
+      if (mapping && mapping.possibleElements.length === 1) {
+        const element = mapping.possibleElements[0];
+        await stagingManager.stage(changeset.id, {
+          type: "delete",
+          elementId: element.elementId,
+          layerName: element.layer,
+          before: {
+            sourceFile: filePath,
+            syncSource: "codebase"
+          },
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }), warnings.push(`File deleted: ${filePath} -> ${element.elementId} (staged for review)`), changeCount++;
+      }
+    }
+    if (mappings.ambiguous.length > 0 && !options.force)
+      for (const ambiguity of mappings.ambiguous)
+        warnings.push(`Ambiguous mapping: ${ambiguity.filePath} -> ${ambiguity.possibleElements.map((e) => e.elementId).join(", ")} (skipped, use --force to proceed)`);
+    return {
+      changesetId: changeset.id,
+      changeCount,
+      warnings
+    };
+  }
+  /**
+   * Execute a complete sync operation for a project
+   */
+  async syncProject(project, options = {}) {
+    const codebasePath = project.source, notes = [];
+    options.verbose && !options.dryRun && notes.push(`Pulling latest from ${codebasePath}...`);
+    const currentCommit = options.dryRun ? await this.getCurrentCommit(codebasePath) : await this.pullCodebase(codebasePath);
+    options.dryRun && notes.push("(DRY RUN - skipping git pull)");
+    const syncStatePath = path.join(this.farmRoot, project.model, ".farm-sync.yaml");
+    await ensureDir(path.dirname(syncStatePath));
+    const syncState = await FarmSyncState.loadOrCreate(syncStatePath, project.name), previousCommit = syncState.lastSyncCommit;
+    if (notes.push(`Current commit: ${currentCommit}`), notes.push(`Previous sync commit: ${previousCommit || "none"}`), !previousCommit)
+      return notes.push("Initial sync - recording baseline only"), options.dryRun ? notes.push("(DRY RUN - sync state not recorded)") : (syncState.recordSync({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        commit: currentCommit,
+        status: "success",
+        files_changed: 0,
+        elements_affected: 0,
+        notes: "Initial sync, no changes to sync"
+      }), await syncState.save(syncStatePath)), {
+        status: "success",
+        projectName: project.name,
+        commitsBefore: "none",
+        commitsAfter: currentCommit.substring(0, 8),
+        filesChanged: { added: [], modified: [], deleted: [] },
+        elementMappings: [],
+        ambiguities: [],
+        changeCount: 0,
+        notes,
+        dryRun: options.dryRun
+      };
+    options.verbose && notes.push(`Computing diff between ${previousCommit.substring(0, 8)} and ${currentCommit.substring(0, 8)}...`);
+    const diff = await this.computeDiff(codebasePath, previousCommit, currentCommit);
+    if (diff.added.length === 0 && diff.modified.length === 0 && diff.deleted.length === 0)
+      return notes.push("No changes detected"), options.dryRun ? notes.push("(DRY RUN - sync state not recorded)") : (syncState.recordSync({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        commit: currentCommit,
+        status: "success",
+        files_changed: 0,
+        elements_affected: 0,
+        notes: "No changes to sync"
+      }), await syncState.save(syncStatePath)), {
+        status: "success",
+        projectName: project.name,
+        commitsBefore: previousCommit.substring(0, 8),
+        commitsAfter: currentCommit.substring(0, 8),
+        filesChanged: diff,
+        elementMappings: [],
+        ambiguities: [],
+        changeCount: 0,
+        notes,
+        dryRun: options.dryRun
+      };
+    if (notes.push(`Files changed: ${diff.added.length} added, ${diff.modified.length} modified, ${diff.deleted.length} deleted`), !this.model)
+      return notes.push("CRITICAL: Model is not loaded, cannot map files to elements"), options.dryRun ? notes.push("(DRY RUN - sync state not recorded)") : (syncState.recordSync({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        commit: previousCommit,
+        // Don't advance lastSyncCommit - stay at previous commit
+        status: "failed",
+        files_changed: diff.added.length + diff.modified.length + diff.deleted.length,
+        elements_affected: 0,
+        notes: "Model not loaded - file changes not synced. Load the model and retry to process these files."
+      }), await syncState.save(syncStatePath)), {
+        status: "failed",
+        projectName: project.name,
+        commitsBefore: previousCommit.substring(0, 8),
+        commitsAfter: currentCommit.substring(0, 8),
+        filesChanged: diff,
+        elementMappings: [],
+        ambiguities: [],
+        changeCount: 0,
+        notes,
+        dryRun: options.dryRun
+      };
+    options.verbose && notes.push("Mapping changed files to model elements...");
+    const mappings = await this.mapFilesToElements();
+    mappings.ambiguous.length > 0 && (syncState.recordAmbiguities(mappings.ambiguous.map((m) => ({
+      filePath: m.filePath,
+      possibleElements: m.possibleElements.map((e) => ({
+        elementId: e.elementId,
+        layer: e.layer,
+        confidence: e.confidence
+      }))
+    }))), notes.push(`Ambiguities detected: ${mappings.ambiguous.length} files`));
+    let changesetId, changeCount = 0;
+    if (!options.dryRun) {
+      const changesetResult = await this.generateChangeset(project, diff, mappings, options);
+      changesetId = changesetResult.changesetId, changeCount = changesetResult.changeCount, notes.push(...changesetResult.warnings);
+    }
+    const syncStatus = mappings.ambiguous.length > 0 && !options.force ? "partial" : "success";
+    return options.dryRun ? notes.push("(DRY RUN - sync state not recorded)") : (syncState.recordSync({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      commit: currentCommit,
+      status: syncStatus,
+      changeset: changesetId,
+      files_changed: diff.added.length + diff.modified.length + diff.deleted.length,
+      elements_affected: mappings.confident.length + mappings.ambiguous.length,
+      notes: notes.join(`
+`)
+    }), await syncState.save(syncStatePath)), {
+      status: syncStatus,
+      projectName: project.name,
+      commitsBefore: previousCommit.substring(0, 8),
+      commitsAfter: currentCommit.substring(0, 8),
+      filesChanged: diff,
+      elementMappings: mappings.confident,
+      ambiguities: mappings.ambiguous,
+      changesetId,
+      changeCount,
+      notes,
+      dryRun: options.dryRun
+    };
+  }
+}
+export {
+  FarmSyncEngine
+};
+//# sourceMappingURL=farm-sync-engine.js.map

package/dist/core/farm-sync-engine.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/farm-sync-engine.ts"],
+  "sourcesContent": ["/**\n * Farm Sync Engine - Orchestrates headless sync pipeline\n *\n * Implements:\n * - Git pull for tracked codebases\n * - Diff computation between sync commits\n * - File-to-element mapping via source references\n * - Changeset generation for affected elements\n * - Staged changeset integration\n */\n\nimport path from \"path\";\nimport { execSync, execFileSync } from \"child_process\";\nimport { fileExists, ensureDir } from \"../utils/file-io.js\";\nimport { FarmSyncState } from \"./farm-sync-state.js\";\nimport { Model } from \"./model.js\";\nimport { StagingAreaManager } from \"./staging-area.js\";\nimport { getErrorMessage } from \"../utils/errors.js\";\nimport type { FarmProject } from \"./farm-manifest.js\";\n\n/**\n * Options for sync operation\n */\nexport interface SyncOptions {\n  dryRun?: boolean; // Preview without creating changeset\n  force?: boolean; // Proceed despite ambiguities\n  verbose?: boolean; // Detailed output\n}\n\n/**\n * Result of file diff analysis\n */\nexport interface FileDiffResult {\n  added: string[];\n  modified: string[];\n  deleted: string[];\n}\n\n/**\n * Mapping of file path to model elements\n */\nexport interface FileElementMapping {\n  filePath: string;\n  possibleElements: Array<{\n    elementId: string;\n    layer: string;\n    confidence: number; // 0-100\n    sourceRef: {\n      file: string;\n      symbol?: string;\n    };\n  }>;\n}\n\n/**\n * Result of a sync operation\n */\nexport interface SyncResult {\n  status: \"success\" | \"partial\" | \"failed\";\n  projectName: string;\n  commitsBefore: string;\n  commitsAfter: string;\n  filesChanged: FileDiffResult;\n  elementMappings: FileElementMapping[];\n  ambiguities: FileElementMapping[]; // Mappings with low confidence\n  changesetId?: string; // ID of generated changeset if applicable\n  changeCount: number; // Total staged changes\n  notes: string[];\n  dryRun?: boolean; // True if this was a dry run (no state changed)\n}\n\n/**\n * FarmSyncEngine - Orchestrates the sync pipeline\n * Model parameter is optional - only required for sync operations, not for pull\n */\nexport class FarmSyncEngine {\n  private farmRoot: string;\n  private model: Model | null;\n\n  constructor(farmRoot: string, model?: Model) {\n    this.farmRoot = farmRoot;\n    this.model = model || null;\n  }\n\n  /**\n   * Pull latest changes from remote for a codebase\n   * @param codebasePath - Relative path to codebase folder\n   * @returns Updated commit SHA\n   */\n  async pullCodebase(codebasePath: string): Promise<string> {\n    const fullPath = path.join(this.farmRoot, codebasePath);\n\n    if (!(await fileExists(fullPath))) {\n      throw new Error(`Codebase directory not found: ${codebasePath}`);\n    }\n\n    try {\n      // Try to fetch latest if remote exists\n      try {\n        execSync(\"git fetch --prune\", { cwd: fullPath, stdio: \"pipe\" });\n      } catch (fetchError) {\n        const fetchMsg = getErrorMessage(fetchError);\n        // Only treat \"no remote\" as acceptable; re-throw auth, merge, and network errors\n        const isNoRemote = fetchMsg.includes(\"No remote repository specified\") ||\n                          fetchMsg.includes(\"no remote\");\n        if (!isNoRemote) {\n          throw new Error(`git fetch failed: ${fetchMsg}`);\n        }\n      }\n\n      // Try to pull if remote exists\n      try {\n        execSync(\"git pull --no-rebase\", { cwd: fullPath, stdio: \"pipe\" });\n      } catch (pullError) {\n        const pullMsg = getErrorMessage(pullError);\n        // Only treat \"no remote\" or \"no tracking information\" as acceptable; re-throw auth, merge, and network errors\n        const isAcceptable = pullMsg.includes(\"No remote repository specified\") ||\n                             pullMsg.includes(\"no remote\") ||\n                             pullMsg.includes(\"no tracking information\");\n        if (!isAcceptable) {\n          throw new Error(`git pull failed: ${pullMsg}`);\n        }\n      }\n\n      // Get current HEAD commit\n      const commit = execSync(\"git rev-parse HEAD\", { cwd: fullPath, encoding: \"utf-8\" }).trim();\n\n      return commit;\n    } catch (error) {\n      throw new Error(`Failed to pull codebase '${codebasePath}': ${getErrorMessage(error)}`);\n    }\n  }\n\n  /**\n   * Get the current HEAD commit SHA for a codebase\n   */\n  async getCurrentCommit(codebasePath: string): Promise<string> {\n    const fullPath = path.join(this.farmRoot, codebasePath);\n\n    if (!(await fileExists(fullPath))) {\n      throw new Error(`Codebase directory not found: ${codebasePath}`);\n    }\n\n    try {\n      const commit = execSync(\"git rev-parse HEAD\", { cwd: fullPath, encoding: \"utf-8\" }).trim();\n      return commit;\n    } catch (error) {\n      throw new Error(`Failed to get current commit for '${codebasePath}': ${getErrorMessage(error)}`);\n    }\n  }\n\n  /**\n   * Compute diff between two commits\n   * Commit SHAs are validated before use to prevent command injection\n   */\n  async computeDiff(codebasePath: string, fromCommit: string, toCommit: string): Promise<FileDiffResult> {\n    const fullPath = path.join(this.farmRoot, codebasePath);\n\n    if (!(await fileExists(fullPath))) {\n      throw new Error(`Codebase directory not found: ${codebasePath}`);\n    }\n\n    // Validate commit SHAs to prevent command injection\n    const commitShaRegex = /^[0-9a-f]{7,40}$/i;\n    if (!commitShaRegex.test(fromCommit) || !commitShaRegex.test(toCommit)) {\n      throw new Error(\n        `Invalid commit SHA format. Expected 7-40 character hex string. Got: ${fromCommit}, ${toCommit}`\n      );\n    }\n\n    try {\n      // Get diff status between commits using execFileSync to avoid shell interpretation\n      const diffOutput = execFileSync(\"git\", [\"diff\", \"--name-status\", `${fromCommit}...${toCommit}`], {\n        cwd: fullPath,\n        encoding: \"utf-8\",\n      });\n\n      const added: string[] = [];\n      const modified: string[] = [];\n      const deleted: string[] = [];\n\n      for (const line of diffOutput.trim().split(\"\\n\")) {\n        if (!line) continue;\n\n        const [status, ...fileParts] = line.split(\"\\t\");\n        const filePath = fileParts.join(\"\\t\"); // Handle paths with tabs\n\n        switch (status) {\n          case \"A\":\n            added.push(filePath);\n            break;\n          case \"M\":\n            modified.push(filePath);\n            break;\n          case \"D\":\n            deleted.push(filePath);\n            break;\n          default:\n            if (status.startsWith(\"R\")) {\n              // Handle renames (R100, R087, R095, etc. - any similarity index)\n              // Report as both a delete of the old name and add of the new name\n              const [oldPath, newPath] = fileParts;\n              deleted.push(oldPath);\n              added.push(newPath);\n            } else if (status.startsWith(\"C\")) {\n              // Handle copies (C100, C087, etc. - any similarity index)\n              // Report as add of new file\n              added.push(fileParts[1]);\n            }\n            break;\n          // Ignore other statuses\n        }\n      }\n\n      return { added, modified, deleted };\n    } catch (error) {\n      throw new Error(`Failed to compute diff for '${codebasePath}': ${getErrorMessage(error)}`);\n    }\n  }\n\n  /**\n   * Map changed files to model elements using source references\n   * Looks at each model element's source references and matches against changed files\n   * Returns empty results if model is not available\n   */\n  async mapFilesToElements(): Promise<{ confident: FileElementMapping[]; ambiguous: FileElementMapping[] }> {\n    if (!this.model) {\n      return { confident: [], ambiguous: [] };\n    }\n\n    const confident: Map<string, FileElementMapping> = new Map();\n    const ambiguous: Map<string, FileElementMapping> = new Map();\n\n    // Iterate through all layers and elements\n    for (const layer of this.model.layers.values()) {\n      for (const element of layer.listElements()) {\n        if (!element.source_reference) continue;\n\n        const sourceRef = element.source_reference;\n        if (!sourceRef.locations || sourceRef.locations.length === 0) continue;\n\n        // Match each source location against potential changed files\n        for (const location of sourceRef.locations) {\n          // Use file path as key\n          const filePath = location.file;\n\n          if (!confident.has(filePath) && !ambiguous.has(filePath)) {\n            const mapping: FileElementMapping = {\n              filePath,\n              possibleElements: [\n                {\n                  elementId: element.id,\n                  layer: layer.name,\n                  confidence: 100, // Exact match from source reference\n                  sourceRef: location,\n                },\n              ],\n            };\n            confident.set(filePath, mapping);\n          } else if (confident.has(filePath)) {\n            // Multiple elements reference the same file - mark as ambiguous\n            const existing = confident.get(filePath)!;\n            confident.delete(filePath);\n\n            existing.possibleElements.push({\n              elementId: element.id,\n              layer: layer.name,\n              confidence: 100,\n              sourceRef: location,\n            });\n\n            ambiguous.set(filePath, existing);\n          } else {\n            // Already ambiguous, add another possibility\n            const existing = ambiguous.get(filePath)!;\n            existing.possibleElements.push({\n              elementId: element.id,\n              layer: layer.name,\n              confidence: 100,\n              sourceRef: location,\n            });\n          }\n        }\n      }\n    }\n\n    return {\n      confident: Array.from(confident.values()),\n      ambiguous: Array.from(ambiguous.values()),\n    };\n  }\n\n  /**\n   * Generate a changeset from file-to-element mappings\n   * Creates add/update/delete changes based on the diff and mappings\n   * Stages changes into the changeset for review before commit\n   */\n  async generateChangeset(\n    project: FarmProject,\n    diff: FileDiffResult,\n    mappings: { confident: FileElementMapping[]; ambiguous: FileElementMapping[] },\n    options: SyncOptions = {}\n  ): Promise<{ changesetId: string; changeCount: number; warnings: string[] }> {\n    if (!this.model) {\n      throw new Error(\"Model is required for changeset generation\");\n    }\n\n    const projectModelPath = path.join(this.farmRoot, project.model);\n    const stagingManager = new StagingAreaManager(projectModelPath, this.model);\n\n    // Create a new changeset\n    const changesetName = `farm-sync-${project.name}-${Date.now()}`;\n    const changeset = await stagingManager.create(changesetName, `Auto-generated from farm sync of ${project.name}`);\n\n    if (!changeset.id) {\n      throw new Error(\"Failed to create changeset - no ID assigned\");\n    }\n\n    const warnings: string[] = [];\n    let changeCount = 0;\n\n    // Create a map of file path -> confident mapping for quick lookup\n    const confidentMap = new Map(mappings.confident.map((m) => [m.filePath, m]));\n\n    // Process added files\n    for (const filePath of diff.added) {\n      const mapping = confidentMap.get(filePath);\n      if (mapping && mapping.possibleElements.length === 1) {\n        const element = mapping.possibleElements[0];\n        // Stage the change\n        await stagingManager.stage(changeset.id, {\n          type: \"add\",\n          elementId: element.elementId,\n          layerName: element.layer,\n          after: {\n            sourceFile: filePath,\n            syncSource: \"codebase\",\n            timestamp: new Date().toISOString(),\n          },\n          timestamp: new Date().toISOString(),\n        });\n        warnings.push(\n          `File added: ${filePath} -> ${element.elementId} (staged for review, verify content accuracy)`\n        );\n        changeCount++;\n      }\n    }\n\n    // Process modified files\n    for (const filePath of diff.modified) {\n      const mapping = confidentMap.get(filePath);\n      if (mapping && mapping.possibleElements.length === 1) {\n        const element = mapping.possibleElements[0];\n        // Stage the change\n        await stagingManager.stage(changeset.id, {\n          type: \"update\",\n          elementId: element.elementId,\n          layerName: element.layer,\n          before: {\n            sourceFile: filePath,\n            syncSource: \"codebase\",\n          },\n          after: {\n            sourceFile: filePath,\n            syncSource: \"codebase\",\n            timestamp: new Date().toISOString(),\n          },\n          timestamp: new Date().toISOString(),\n        });\n        warnings.push(`File modified: ${filePath} -> ${element.elementId} (staged for review)`);\n        changeCount++;\n      }\n    }\n\n    // Process deleted files\n    for (const filePath of diff.deleted) {\n      const mapping = confidentMap.get(filePath);\n      if (mapping && mapping.possibleElements.length === 1) {\n        const element = mapping.possibleElements[0];\n        // Stage the change\n        await stagingManager.stage(changeset.id, {\n          type: \"delete\",\n          elementId: element.elementId,\n          layerName: element.layer,\n          before: {\n            sourceFile: filePath,\n            syncSource: \"codebase\",\n          },\n          timestamp: new Date().toISOString(),\n        });\n        warnings.push(`File deleted: ${filePath} -> ${element.elementId} (staged for review)`);\n        changeCount++;\n      }\n    }\n\n    // Flag ambiguities\n    if (mappings.ambiguous.length > 0 && !options.force) {\n      for (const ambiguity of mappings.ambiguous) {\n        warnings.push(\n          `Ambiguous mapping: ${ambiguity.filePath} -> ${ambiguity.possibleElements.map((e) => e.elementId).join(\", \")} (skipped, use --force to proceed)`\n        );\n      }\n    }\n\n    return {\n      changesetId: changeset.id,\n      changeCount,\n      warnings,\n    };\n  }\n\n  /**\n   * Execute a complete sync operation for a project\n   */\n  async syncProject(project: FarmProject, options: SyncOptions = {}): Promise<SyncResult> {\n    const codebasePath = project.source;\n    const notes: string[] = [];\n\n    // Step 1: Get current commit (pull only if not dry run)\n    if (options.verbose && !options.dryRun) {\n      notes.push(`Pulling latest from ${codebasePath}...`);\n    }\n    const currentCommit = options.dryRun\n      ? await this.getCurrentCommit(codebasePath)\n      : await this.pullCodebase(codebasePath);\n    if (options.dryRun) {\n      notes.push(\"(DRY RUN - skipping git pull)\");\n    }\n\n    // Step 2: Load sync state\n    const syncStatePath = path.join(this.farmRoot, project.model, \".farm-sync.yaml\");\n    await ensureDir(path.dirname(syncStatePath));\n    const syncState = await FarmSyncState.loadOrCreate(syncStatePath, project.name);\n\n    const previousCommit = syncState.lastSyncCommit;\n    notes.push(`Current commit: ${currentCommit}`);\n    notes.push(`Previous sync commit: ${previousCommit || \"none\"}`);\n\n    // Step 3: If no previous sync, this is initial sync - just record state\n    if (!previousCommit) {\n      notes.push(\"Initial sync - recording baseline only\");\n      if (!options.dryRun) {\n        syncState.recordSync({\n          timestamp: new Date().toISOString(),\n          commit: currentCommit,\n          status: \"success\",\n          files_changed: 0,\n          elements_affected: 0,\n          notes: \"Initial sync, no changes to sync\",\n        });\n        await syncState.save(syncStatePath);\n      } else {\n        notes.push(\"(DRY RUN - sync state not recorded)\");\n      }\n\n      return {\n        status: \"success\",\n        projectName: project.name,\n        commitsBefore: \"none\",\n        commitsAfter: currentCommit.substring(0, 8),\n        filesChanged: { added: [], modified: [], deleted: [] },\n        elementMappings: [],\n        ambiguities: [],\n        changeCount: 0,\n        notes,\n        dryRun: options.dryRun,\n      };\n    }\n\n    // Step 4: Compute diff\n    if (options.verbose) {\n      notes.push(`Computing diff between ${previousCommit.substring(0, 8)} and ${currentCommit.substring(0, 8)}...`);\n    }\n    const diff = await this.computeDiff(codebasePath, previousCommit, currentCommit);\n\n    // If no changes, return early\n    if (diff.added.length === 0 && diff.modified.length === 0 && diff.deleted.length === 0) {\n      notes.push(\"No changes detected\");\n      if (!options.dryRun) {\n        syncState.recordSync({\n          timestamp: new Date().toISOString(),\n          commit: currentCommit,\n          status: \"success\",\n          files_changed: 0,\n          elements_affected: 0,\n          notes: \"No changes to sync\",\n        });\n        await syncState.save(syncStatePath);\n      } else {\n        notes.push(\"(DRY RUN - sync state not recorded)\");\n      }\n\n      return {\n        status: \"success\",\n        projectName: project.name,\n        commitsBefore: previousCommit.substring(0, 8),\n        commitsAfter: currentCommit.substring(0, 8),\n        filesChanged: diff,\n        elementMappings: [],\n        ambiguities: [],\n        changeCount: 0,\n        notes,\n        dryRun: options.dryRun,\n      };\n    }\n\n    notes.push(\n      `Files changed: ${diff.added.length} added, ${diff.modified.length} modified, ${diff.deleted.length} deleted`\n    );\n\n    // Step 5: Check that model is available before attempting to map files\n    if (!this.model) {\n      notes.push(\"CRITICAL: Model is not loaded, cannot map files to elements\");\n      if (!options.dryRun) {\n        syncState.recordSync({\n          timestamp: new Date().toISOString(),\n          commit: previousCommit, // Don't advance lastSyncCommit - stay at previous commit\n          status: \"failed\",\n          files_changed: diff.added.length + diff.modified.length + diff.deleted.length,\n          elements_affected: 0,\n          notes: \"Model not loaded - file changes not synced. Load the model and retry to process these files.\",\n        });\n        await syncState.save(syncStatePath);\n      } else {\n        notes.push(\"(DRY RUN - sync state not recorded)\");\n      }\n\n      return {\n        status: \"failed\",\n        projectName: project.name,\n        commitsBefore: previousCommit.substring(0, 8),\n        commitsAfter: currentCommit.substring(0, 8),\n        filesChanged: diff,\n        elementMappings: [],\n        ambiguities: [],\n        changeCount: 0,\n        notes,\n        dryRun: options.dryRun,\n      };\n    }\n\n    // Step 6: Map files to elements\n    if (options.verbose) {\n      notes.push(\"Mapping changed files to model elements...\");\n    }\n    const mappings = await this.mapFilesToElements();\n\n    // Step 7: Record ambiguities in sync state\n    if (mappings.ambiguous.length > 0) {\n      syncState.recordAmbiguities(\n        mappings.ambiguous.map((m) => ({\n          filePath: m.filePath,\n          possibleElements: m.possibleElements.map((e) => ({\n            elementId: e.elementId,\n            layer: e.layer,\n            confidence: e.confidence,\n          })),\n        }))\n      );\n      notes.push(`Ambiguities detected: ${mappings.ambiguous.length} files`);\n    }\n\n    // Step 8: Generate changeset\n    let changesetId: string | undefined;\n    let changeCount = 0;\n\n    if (!options.dryRun) {\n      const changesetResult = await this.generateChangeset(project, diff, mappings, options);\n      changesetId = changesetResult.changesetId;\n      changeCount = changesetResult.changeCount;\n      notes.push(...changesetResult.warnings);\n    }\n\n    // Step 9: Record sync in state (skip for dry run)\n    const syncStatus = mappings.ambiguous.length > 0 && !options.force ? \"partial\" : \"success\";\n\n    if (!options.dryRun) {\n      syncState.recordSync({\n        timestamp: new Date().toISOString(),\n        commit: currentCommit,\n        status: syncStatus,\n        changeset: changesetId,\n        files_changed: diff.added.length + diff.modified.length + diff.deleted.length,\n        elements_affected: mappings.confident.length + mappings.ambiguous.length,\n        notes: notes.join(\"\\n\"),\n      });\n      await syncState.save(syncStatePath);\n    } else {\n      notes.push(\"(DRY RUN - sync state not recorded)\");\n    }\n\n    return {\n      status: syncStatus,\n      projectName: project.name,\n      commitsBefore: previousCommit.substring(0, 8),\n      commitsAfter: currentCommit.substring(0, 8),\n      filesChanged: diff,\n      elementMappings: mappings.confident,\n      ambiguities: mappings.ambiguous,\n      changesetId,\n      changeCount,\n      notes,\n      dryRun: options.dryRun,\n    };\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/core/farm-sync-state.js

@@ -0,0 +1,159 @@
+import yaml from "yaml";
+import { readFile, writeFile, fileExists } from "../utils/file-io.js";
+class FarmSyncState {
+  projectName;
+  lastSyncCommit;
+  lastSyncTimestamp;
+  syncHistory;
+  ambiguities;
+  filePath;
+  constructor(data) {
+    this.projectName = data.project_name, this.lastSyncCommit = data.last_sync_commit, this.lastSyncTimestamp = data.last_sync_timestamp, this.syncHistory = data.sync_history || [], this.ambiguities = data.ambiguities?.map((a) => ({
+      filePath: a.file_path,
+      possibleElements: a.possible_elements.map((e) => ({
+        elementId: e.element_id,
+        layer: e.layer,
+        confidence: e.confidence
+      }))
+    })) || [];
+  }
+  /**
+   * Load farm sync state from file
+   * @param filePath - Path to .farm-sync.yaml
+   * @returns FarmSyncState instance
+   */
+  static async load(filePath) {
+    if (!await fileExists(filePath))
+      throw new Error(`Farm sync state file not found: ${filePath}`);
+    const content = await readFile(filePath), rawData = yaml.parse(content);
+    if (!rawData)
+      throw new Error(`Invalid farm sync state: file is empty or contains invalid YAML at ${filePath}`);
+    const data = {
+      project_name: rawData.project_name || rawData.projectName,
+      last_sync_commit: rawData.last_sync_commit || rawData.lastSyncCommit,
+      last_sync_timestamp: rawData.last_sync_timestamp || rawData.lastSyncTimestamp,
+      sync_history: (rawData.sync_history || rawData.syncHistory || []).map((record) => ({
+        timestamp: record.timestamp,
+        commit: record.commit,
+        changeset: record.changeset || record.changesetId,
+        files_changed: record.files_changed || record.filesChanged,
+        elements_affected: record.elements_affected || record.elementsAffected,
+        status: record.status,
+        notes: record.notes
+      })),
+      ambiguities: (rawData.ambiguities || []).map((a) => ({
+        file_path: a.file_path || a.filePath,
+        possible_elements: (a.possible_elements || a.possibleElements || []).map((e) => ({
+          element_id: e.element_id || e.elementId,
+          layer: e.layer,
+          confidence: e.confidence
+        }))
+      }))
+    };
+    if (!data.project_name)
+      throw new Error("Farm sync state must have a 'project_name' field");
+    const state = new FarmSyncState(data);
+    return state.filePath = filePath, state;
+  }
+  /**
+   * Create a new farm sync state
+   * @param projectName - Name of the project
+   * @param options - Optional initial state
+   * @returns FarmSyncState instance
+   */
+  static create(projectName, options = {}) {
+    return new FarmSyncState({
+      project_name: projectName,
+      last_sync_commit: options.lastSyncCommit,
+      last_sync_timestamp: options.lastSyncTimestamp,
+      sync_history: [],
+      ambiguities: []
+    });
+  }
+  /**
+   * Load or create farm sync state
+   * @param filePath - Path to .farm-sync.yaml
+   * @param projectName - Project name (used if creating new)
+   * @returns FarmSyncState instance
+   */
+  static async loadOrCreate(filePath, projectName) {
+    return await fileExists(filePath) ? this.load(filePath) : this.create(projectName);
+  }
+  /**
+   * Save state to file
+   * @param filePath - Path where to save .farm-sync.yaml
+   */
+  async save(filePath) {
+    const targetPath = filePath || this.filePath;
+    if (!targetPath)
+      throw new Error("No file path specified for saving farm sync state");
+    const data = this.toJSON(), yamlContent = yaml.stringify(data, { lineWidth: 0 });
+    await writeFile(targetPath, yamlContent), this.filePath = targetPath;
+  }
+  /**
+   * Record a sync (successful or failed)
+   */
+  recordSync(record) {
+    const status = record.status || "success";
+    (status === "success" || status === "partial") && (this.lastSyncCommit = record.commit, this.lastSyncTimestamp = record.timestamp), this.syncHistory.push({
+      timestamp: record.timestamp,
+      commit: record.commit,
+      status,
+      changeset: record.changeset,
+      files_changed: record.files_changed,
+      elements_affected: record.elements_affected,
+      notes: record.notes
+    }), this.syncHistory.length > 100 && (this.syncHistory = this.syncHistory.slice(-100));
+  }
+  /**
+   * Record ambiguous file-to-element mappings for review
+   */
+  recordAmbiguities(ambiguities) {
+    this.ambiguities = ambiguities;
+  }
+  /**
+   * Clear ambiguities after review
+   */
+  clearAmbiguities() {
+    this.ambiguities = [];
+  }
+  /**
+   * Get the last sync record if any
+   */
+  getLastSync() {
+    return this.syncHistory.length > 0 ? this.syncHistory[this.syncHistory.length - 1] : void 0;
+  }
+  /**
+   * Serialize to JSON representation for saving
+   */
+  toJSON() {
+    return {
+      project_name: this.projectName,
+      last_sync_commit: this.lastSyncCommit,
+      last_sync_timestamp: this.lastSyncTimestamp,
+      sync_history: this.syncHistory.map((record) => ({
+        timestamp: record.timestamp,
+        commit: record.commit,
+        changeset: record.changeset,
+        files_changed: record.files_changed,
+        elements_affected: record.elements_affected,
+        status: record.status,
+        notes: record.notes
+      })),
+      ...this.ambiguities.length > 0 && {
+        ambiguities: this.ambiguities.map((a) => ({
+          file_path: a.filePath,
+          possible_elements: a.possibleElements.map((e) => ({
+            element_id: e.elementId,
+            layer: e.layer,
+            confidence: e.confidence
+          }))
+        }))
+      }
+    };
+  }
+}
+export {
+  FarmSyncState
+};
+//# sourceMappingURL=farm-sync-state.js.map

package/dist/core/farm-sync-state.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/farm-sync-state.ts"],
+  "sourcesContent": ["/**\n * Farm Sync State - Manages .farm-sync.yaml per project\n *\n * Tracks sync history, last sync commit, and timestamps for each project.\n */\n\nimport yaml from \"yaml\";\nimport { readFile, writeFile, fileExists } from \"../utils/file-io.js\";\n\n/**\n * Represents a single sync record\n */\nexport interface SyncRecord {\n  timestamp: string; // ISO 8601 timestamp\n  commit: string; // Commit SHA where sync occurred\n  changeset?: string; // ID of generated changeset\n  files_changed?: number; // Number of files that changed\n  elements_affected?: number; // Number of model elements affected\n  status: \"success\" | \"partial\" | \"failed\"; // Status of the sync\n  notes?: string; // Optional notes about the sync\n}\n\n/**\n * Farm sync state for a single project\n */\nexport interface FarmSyncStateData {\n  project_name: string;\n  last_sync_commit?: string; // Last successful sync commit SHA\n  last_sync_timestamp?: string; // ISO 8601 timestamp\n  sync_history: SyncRecord[]; // Complete history of syncs\n  ambiguities?: Array<{\n    file_path: string;\n    possible_elements: Array<{\n      element_id: string;\n      layer: string;\n      confidence: number; // 0-100 confidence score\n    }>;\n  }>; // Ambiguous file-to-element mappings flagged for review\n}\n\n/**\n * FarmSyncState class - Load, validate, and save farm sync state per project\n */\nexport class FarmSyncState {\n  projectName: string;\n  lastSyncCommit?: string;\n  lastSyncTimestamp?: string;\n  syncHistory: SyncRecord[];\n  ambiguities: Array<{\n    filePath: string;\n    possibleElements: Array<{\n      elementId: string;\n      layer: string;\n      confidence: number;\n    }>;\n  }>;\n  filePath?: string;\n\n  constructor(data: FarmSyncStateData) {\n    this.projectName = data.project_name;\n    this.lastSyncCommit = data.last_sync_commit;\n    this.lastSyncTimestamp = data.last_sync_timestamp;\n    this.syncHistory = data.sync_history || [];\n    this.ambiguities = data.ambiguities?.map(a => ({\n      filePath: a.file_path,\n      possibleElements: a.possible_elements.map(e => ({\n        elementId: e.element_id,\n        layer: e.layer,\n        confidence: e.confidence,\n      })),\n    })) || [];\n  }\n\n  /**\n   * Load farm sync state from file\n   * @param filePath - Path to .farm-sync.yaml\n   * @returns FarmSyncState instance\n   */\n  static async load(filePath: string): Promise<FarmSyncState> {\n    if (!(await fileExists(filePath))) {\n      throw new Error(`Farm sync state file not found: ${filePath}`);\n    }\n\n    const content = await readFile(filePath);\n    const rawData = yaml.parse(content) as any;\n\n    if (!rawData) {\n      throw new Error(\n        `Invalid farm sync state: file is empty or contains invalid YAML at ${filePath}`\n      );\n    }\n\n    // Handle both old (camelCase) and new (snake_case) formats for backward compatibility\n    const data: FarmSyncStateData = {\n      project_name: rawData.project_name || rawData.projectName,\n      last_sync_commit: rawData.last_sync_commit || rawData.lastSyncCommit,\n      last_sync_timestamp: rawData.last_sync_timestamp || rawData.lastSyncTimestamp,\n      sync_history: (rawData.sync_history || rawData.syncHistory || []).map((record: any) => ({\n        timestamp: record.timestamp,\n        commit: record.commit,\n        changeset: record.changeset || record.changesetId,\n        files_changed: record.files_changed || record.filesChanged,\n        elements_affected: record.elements_affected || record.elementsAffected,\n        status: record.status,\n        notes: record.notes,\n      })),\n      ambiguities: (rawData.ambiguities || []).map((a: any) => ({\n        file_path: a.file_path || a.filePath,\n        possible_elements: (a.possible_elements || a.possibleElements || []).map((e: any) => ({\n          element_id: e.element_id || e.elementId,\n          layer: e.layer,\n          confidence: e.confidence,\n        })),\n      })),\n    };\n\n    if (!data.project_name) {\n      throw new Error(\"Farm sync state must have a 'project_name' field\");\n    }\n\n    const state = new FarmSyncState(data);\n    state.filePath = filePath;\n    return state;\n  }\n\n  /**\n   * Create a new farm sync state\n   * @param projectName - Name of the project\n   * @param options - Optional initial state\n   * @returns FarmSyncState instance\n   */\n  static create(\n    projectName: string,\n    options: {\n      lastSyncCommit?: string;\n      lastSyncTimestamp?: string;\n    } = {}\n  ): FarmSyncState {\n    return new FarmSyncState({\n      project_name: projectName,\n      last_sync_commit: options.lastSyncCommit,\n      last_sync_timestamp: options.lastSyncTimestamp,\n      sync_history: [],\n      ambiguities: [],\n    });\n  }\n\n  /**\n   * Load or create farm sync state\n   * @param filePath - Path to .farm-sync.yaml\n   * @param projectName - Project name (used if creating new)\n   * @returns FarmSyncState instance\n   */\n  static async loadOrCreate(filePath: string, projectName: string): Promise<FarmSyncState> {\n    if (await fileExists(filePath)) {\n      return this.load(filePath);\n    }\n    return this.create(projectName);\n  }\n\n  /**\n   * Save state to file\n   * @param filePath - Path where to save .farm-sync.yaml\n   */\n  async save(filePath?: string): Promise<void> {\n    const targetPath = filePath || this.filePath;\n    if (!targetPath) {\n      throw new Error(\"No file path specified for saving farm sync state\");\n    }\n\n    const data = this.toJSON();\n    const yamlContent = yaml.stringify(data, { lineWidth: 0 });\n\n    await writeFile(targetPath, yamlContent);\n    this.filePath = targetPath;\n  }\n\n  /**\n   * Record a sync (successful or failed)\n   */\n  recordSync(record: Omit<SyncRecord, \"status\"> & { status?: \"success\" | \"partial\" | \"failed\" }): void {\n    const status = record.status || \"success\";\n\n    // Update lastSyncCommit on successful and partial syncs to avoid reprocessing confident files.\n    // Failed syncs do not advance the pointer (will retry from same point).\n    // Partial syncs advance because confident files have been processed and staged;\n    // ambiguous files are tracked separately for manual review.\n    if (status === \"success\" || status === \"partial\") {\n      this.lastSyncCommit = record.commit;\n      this.lastSyncTimestamp = record.timestamp;\n    }\n\n    this.syncHistory.push({\n      timestamp: record.timestamp,\n      commit: record.commit,\n      status,\n      changeset: record.changeset,\n      files_changed: record.files_changed,\n      elements_affected: record.elements_affected,\n      notes: record.notes,\n    });\n\n    // Keep history trimmed to last 100 syncs\n    if (this.syncHistory.length > 100) {\n      this.syncHistory = this.syncHistory.slice(-100);\n    }\n  }\n\n  /**\n   * Record ambiguous file-to-element mappings for review\n   */\n  recordAmbiguities(\n    ambiguities: Array<{\n      filePath: string;\n      possibleElements: Array<{\n        elementId: string;\n        layer: string;\n        confidence: number;\n      }>;\n    }>\n  ): void {\n    this.ambiguities = ambiguities;\n  }\n\n  /**\n   * Clear ambiguities after review\n   */\n  clearAmbiguities(): void {\n    this.ambiguities = [];\n  }\n\n  /**\n   * Get the last sync record if any\n   */\n  getLastSync(): SyncRecord | undefined {\n    return this.syncHistory.length > 0 ? this.syncHistory[this.syncHistory.length - 1] : undefined;\n  }\n\n  /**\n   * Serialize to JSON representation for saving\n   */\n  toJSON(): FarmSyncStateData {\n    return {\n      project_name: this.projectName,\n      last_sync_commit: this.lastSyncCommit,\n      last_sync_timestamp: this.lastSyncTimestamp,\n      sync_history: this.syncHistory.map(record => ({\n        timestamp: record.timestamp,\n        commit: record.commit,\n        changeset: record.changeset,\n        files_changed: record.files_changed,\n        elements_affected: record.elements_affected,\n        status: record.status,\n        notes: record.notes,\n      })),\n      ...(this.ambiguities.length > 0 && {\n        ambiguities: this.ambiguities.map(a => ({\n          file_path: a.filePath,\n          possible_elements: a.possibleElements.map(e => ({\n            element_id: e.elementId,\n            layer: e.layer,\n            confidence: e.confidence,\n          })),\n        }))\n      }),\n    };\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/core/manifest.js

@@ -5,10 +5,13 @@ class Manifest {
   author;
   created;
   modified;
+  cliVersion;
   specVersion;
   changeset_history;
+  models;
+  codebase_path;
   constructor(data) {
-    this.name = data.name, this.version = data.version, this.description = data.description, this.author = data.author, this.created = data.created ?? (/* @__PURE__ */ new Date()).toISOString(), this.modified = data.modified ?? (/* @__PURE__ */ new Date()).toISOString(), this.specVersion = data.specVersion, this.changeset_history = this.migrateChangesetHistory(data.changeset_history);
+    this.name = data.name, this.version = data.version, this.description = data.description, this.author = data.author, this.created = data.created ?? (/* @__PURE__ */ new Date()).toISOString(), this.modified = data.modified ?? (/* @__PURE__ */ new Date()).toISOString(), this.cliVersion = data.cliVersion, this.specVersion = data.specVersion, this.models = data.models, this.codebase_path = data.codebase_path, this.changeset_history = this.migrateChangesetHistory(data.changeset_history);
   }
   /**
    * Migrate changeset history from legacy field names to new format
@@ -45,7 +48,7 @@ class Manifest {
    * Serialize to JSON representation
    *
    * Converts the Manifest to a JSON-serializable object that includes project
-   * metadata and changeset history.
+   * metadata, changeset history, and external model declarations.
    *
    * @returns ManifestData object suitable for JSON serialization
    */
@@ -56,7 +59,7 @@ class Manifest {
       created: this.created,
       modified: this.modified
     };
-    return this.description && (result.description = this.description), this.author && (result.author = this.author), this.specVersion && (result.specVersion = this.specVersion), this.changeset_history && this.changeset_history.length > 0 && (result.changeset_history = this.changeset_history), result;
+    return this.description && (result.description = this.description), this.author && (result.author = this.author), this.cliVersion && (result.cliVersion = this.cliVersion), this.specVersion && (result.specVersion = this.specVersion), this.codebase_path && (result.codebase_path = this.codebase_path), this.changeset_history && this.changeset_history.length > 0 && (result.changeset_history = this.changeset_history), this.models && Object.keys(this.models).length > 0 && (result.models = this.models), result;
   }
   /**
    * Create Manifest from JSON string