opkg 0.9.2 → 0.9.4

package/packages/cli/dist/save-24TESYKI.js

@@ -0,0 +1,1728 @@
+#!/usr/bin/env node
+import {
+  assertMutableSourceOrThrow,
+  isRegistryPath
+} from "./chunk-BVVSU7QD.js";
+import {
+  calculateFileHash,
+  createFlowExecutor
+} from "./chunk-WT4VVCXM.js";
+import "./chunk-IXOEIRDT.js";
+import "./chunk-QURLGVA4.js";
+import {
+  getTargetPath
+} from "./chunk-SHKYQQJJ.js";
+import {
+  readWorkspaceIndex
+} from "./chunk-DEC24S7E.js";
+import "./chunk-VXNS3X5O.js";
+import {
+  resolveDeclaredPath
+} from "./chunk-FRYA3JAQ.js";
+import {
+  createCliExecutionContext,
+  resolveOutput,
+  resolvePrompt
+} from "./chunk-RAKMX654.js";
+import "./chunk-GDVFS3YP.js";
+import "./chunk-427DCURL.js";
+import {
+  arePackageNamesEquivalent,
+  normalizePackageName
+} from "./chunk-VN22A7NW.js";
+import "./chunk-4X2EJHJN.js";
+import {
+  splitFrontmatter
+} from "./chunk-VQ2KY6CK.js";
+import {
+  getGlobalExportFlows,
+  getGlobalImportFlows,
+  getPlatformDefinition,
+  inferPlatformFromWorkspaceFile
+} from "./chunk-N43IXOND.js";
+import {
+  normalizePathForProcessing
+} from "./chunk-YMKK4XPN.js";
+import {
+  FILE_PATTERNS,
+  MUTABILITY,
+  SOURCE_TYPES
+} from "./chunk-IHVZ5AUJ.js";
+import {
+  ensureDir,
+  exists,
+  getStats,
+  readTextFile,
+  walkFiles,
+  writeTextFile
+} from "./chunk-S47F4OG4.js";
+import "./chunk-ID4SVDQZ.js";
+import {
+  logger
+} from "./chunk-5EFWGD33.js";
+
+// ../core/src/core/source-resolution/resolve-package-source.ts
+import path from "path";
+async function resolvePackageSource(workspaceRoot, packageName) {
+  let normalizedTarget = normalizePackageName(packageName), ws = await readWorkspaceIndex(workspaceRoot), entryKey = Object.keys(ws.index.packages ?? {}).find(
+    (k) => arePackageNamesEquivalent(k, normalizedTarget)
+  ), entry = entryKey ? ws.index.packages?.[entryKey] : void 0;
+  if (!entry?.path)
+    throw new Error(
+      `Package '${packageName}' is not installed in this workspace.
+Run 'opkg install ${packageName}' to install it first.`
+    );
+  let resolved = resolveDeclaredPath(entry.path, workspaceRoot), absolutePath = path.join(resolved.absolute, path.sep), mutability = isRegistryPath(absolutePath) ? MUTABILITY.IMMUTABLE : MUTABILITY.MUTABLE, sourceType = isRegistryPath(absolutePath) ? SOURCE_TYPES.REGISTRY : SOURCE_TYPES.PATH;
+  return {
+    packageName: normalizePackageName(entryKey ?? normalizedTarget),
+    absolutePath,
+    declaredPath: resolved.declared,
+    mutability,
+    version: entry.version,
+    sourceType
+  };
+}
+
+// ../core/src/core/save/save-candidate-builder.ts
+import { join, relative } from "path";
+async function buildCandidates(options) {
+  let errors = [];
+  logger.debug("Building workspace candidates from workspace paths");
+  let { candidates: workspaceCandidates, errors: workspaceErrors } = await buildWorkspaceCandidates(
+    options.workspaceRoot,
+    options.packageRoot,
+    options.filesMapping
+  );
+  errors.push(...workspaceErrors), logger.debug("Building local source refs from package source (lazy mode)");
+  let localSourceRefs = await buildLocalSourceRefs(
+    options.packageRoot
+  );
+  return logger.debug(
+    `Built ${localSourceRefs.length} local source refs, ${workspaceCandidates.length} workspace candidates`
+  ), {
+    localCandidates: [],
+    localSourceRefs,
+    workspaceCandidates,
+    errors
+  };
+}
+async function buildLocalSourceRefs(packageRoot) {
+  let refs = [];
+  for await (let absPath of walkFiles(packageRoot)) {
+    let relPath = relative(packageRoot, absPath), normalizedPath = normalizePathForProcessing(relPath);
+    normalizedPath && (normalizedPath.startsWith(".openpackage/") || normalizedPath === "openpackage.yml" || normalizedPath.startsWith(".") && !normalizedPath.match(/^\.(cursor|claude|opencode|windsurf|roo|factory|kilo|qwen|warp|codex|pi|kilocode|agent|augment)/) || (refs.push({ registryPath: normalizedPath, fullPath: absPath }), logger.debug(`Built local source ref: ${normalizedPath}`)));
+  }
+  return refs;
+}
+async function materializeLocalCandidate(ref, packageRoot) {
+  return buildCandidate("local", ref.fullPath, ref.registryPath, {
+    packageRoot,
+    workspaceRoot: packageRoot,
+    inferPlatform: !1,
+    parseMarkdown: !0
+  });
+}
+async function buildWorkspaceCandidates(workspaceRoot, packageRoot, filesMapping) {
+  let candidates = [], errors = [];
+  for (let [rawKey, targets] of Object.entries(filesMapping)) {
+    let registryKey = normalizePathForProcessing(rawKey);
+    if (!registryKey || !Array.isArray(targets)) continue;
+    let isDirectoryMapping = registryKey.endsWith("/");
+    for (let mapping of targets) {
+      let workspaceRel = getTargetPath(mapping), normalizedTargetPath = normalizePathForProcessing(workspaceRel);
+      if (!normalizedTargetPath) continue;
+      let absTargetPath = join(workspaceRoot, normalizedTargetPath), mergeMetadata = typeof mapping == "object" && mapping !== null ? { merge: mapping.merge, keys: mapping.keys } : void 0;
+      if (isDirectoryMapping) {
+        logger.debug(`Enumerating directory mapping: ${registryKey} -> ${normalizedTargetPath}`);
+        try {
+          let files = await collectFilesUnderDirectory(absTargetPath);
+          logger.debug(`Found ${files.length} files under directory ${normalizedTargetPath}`);
+          for (let relFile of files) {
+            let registryPath = normalizePathForProcessing(join(registryKey, relFile));
+            if (!registryPath) continue;
+            let absWorkspaceFile = join(absTargetPath, relFile), candidate = await buildCandidate("workspace", absWorkspaceFile, registryPath, {
+              packageRoot,
+              workspaceRoot,
+              inferPlatform: !0,
+              parseMarkdown: !0,
+              mergeStrategy: mergeMetadata?.merge,
+              mergeKeys: mergeMetadata?.keys
+            });
+            candidate && (candidates.push(candidate), logger.debug(`Built workspace candidate: ${registryPath} (from directory)`));
+          }
+        } catch (error) {
+          let errorMsg = error instanceof Error ? error.message : String(error);
+          errors.push({
+            path: absTargetPath,
+            registryPath: registryKey,
+            reason: `Failed to enumerate directory: ${errorMsg}`
+          }), logger.warn(`Failed to enumerate directory ${absTargetPath}: ${errorMsg}`);
+        }
+      } else {
+        if (!await exists(absTargetPath)) {
+          logger.debug(`Workspace file not found (skipping): ${normalizedTargetPath}`);
+          continue;
+        }
+        let candidate = await buildCandidate("workspace", absTargetPath, registryKey, {
+          packageRoot,
+          workspaceRoot,
+          inferPlatform: !0,
+          parseMarkdown: !0,
+          mergeStrategy: mergeMetadata?.merge,
+          mergeKeys: mergeMetadata?.keys
+        });
+        candidate && (candidates.push(candidate), logger.debug(`Built workspace candidate: ${registryKey}`));
+      }
+    }
+  }
+  return { candidates, errors };
+}
+async function buildCandidate(source, absPath, registryPath, options) {
+  try {
+    let content = await readTextFile(absPath), contentHash = await calculateFileHash(content), stats = await getStats(absPath), rootPath = source === "workspace" ? options.workspaceRoot : options.packageRoot, relPath = absPath.slice(rootPath.length + 1), displayPath = normalizePathForProcessing(relPath) || registryPath, platform;
+    if (options.inferPlatform && source === "workspace") {
+      let sourceDir = deriveSourceDir(displayPath);
+      platform = inferPlatformFromWorkspaceFile(
+        absPath,
+        sourceDir,
+        registryPath,
+        options.workspaceRoot
+      );
+    }
+    let frontmatter, rawFrontmatter, markdownBody, isMarkdown = !1;
+    if (options.parseMarkdown && (absPath.endsWith(".md") || absPath.endsWith(".markdown"))) {
+      isMarkdown = !0;
+      try {
+        let parsed = splitFrontmatter(content);
+        parsed.frontmatter && Object.keys(parsed.frontmatter).length > 0 && (frontmatter = parsed.frontmatter, rawFrontmatter = parsed.rawFrontmatter, markdownBody = parsed.body);
+      } catch (error) {
+        logger.debug(`Failed to parse frontmatter for ${absPath}: ${error}`);
+      }
+    }
+    return {
+      source,
+      registryPath,
+      fullPath: absPath,
+      content,
+      contentHash,
+      mtime: stats.mtime.getTime(),
+      displayPath,
+      platform,
+      frontmatter,
+      rawFrontmatter,
+      markdownBody,
+      isMarkdown,
+      mergeStrategy: options.mergeStrategy,
+      mergeKeys: options.mergeKeys
+    };
+  } catch (error) {
+    let errorMsg = error instanceof Error ? error.message : String(error);
+    return logger.warn(`Failed to build candidate for ${absPath}: ${errorMsg}`), null;
+  }
+}
+async function collectFilesUnderDirectory(absDir) {
+  let collected = [];
+  if (!await exists(absDir))
+    return collected;
+  for await (let absFile of walkFiles(absDir)) {
+    let relPath = absFile.slice(absDir.length + 1).replace(/\\/g, "/");
+    collected.push(relPath);
+  }
+  return collected;
+}
+function deriveSourceDir(relPath) {
+  return relPath && relPath.split("/")[0] || "";
+}
+
+// ../core/src/core/save/save-group-builder.ts
+import { minimatch } from "minimatch";
+function buildCandidateGroups(localRefs, workspaceCandidates, workspaceRoot = process.cwd()) {
+  let map = /* @__PURE__ */ new Map();
+  logger.debug(`Building groups from ${localRefs.length} local refs and ${workspaceCandidates.length} workspace candidates`);
+  for (let ref of localRefs) {
+    let group = ensureGroup(map, ref.registryPath);
+    group.localRef = ref, logger.debug(`Added local ref: ${ref.registryPath}`);
+  }
+  for (let candidate of workspaceCandidates) {
+    logger.debug(
+      `Processing workspace candidate: ${candidate.displayPath} (registryPath: ${candidate.registryPath}, platform: ${candidate.platform || "none"})`
+    );
+    let group = map.get(candidate.registryPath);
+    if (group && logger.debug(`  Found exact match by registryPath: ${candidate.registryPath}`), !group) {
+      let sourceRegistryPath = findSourceFileForWorkspace(
+        candidate,
+        localRefs,
+        workspaceRoot
+      );
+      sourceRegistryPath || (sourceRegistryPath = findSourceFileByFallback(
+        candidate.registryPath,
+        localRefs
+      )), sourceRegistryPath ? (logger.debug(
+        `  Matched to source: workspace ${candidate.displayPath} \u2192 source ${sourceRegistryPath}`
+      ), group = ensureGroup(map, sourceRegistryPath)) : logger.debug("  No source match found");
+    }
+    group || (logger.debug(`  Creating new group with workspace registryPath: ${candidate.registryPath}`), group = ensureGroup(map, candidate.registryPath)), group.workspace.push(candidate);
+  }
+  let allGroups = Array.from(map.values()), activeCount = allGroups.filter((g) => g.workspace.length > 0).length;
+  return logger.debug(`Built ${map.size} candidate groups (${activeCount} with workspace candidates)`), allGroups;
+}
+function findSourceFileByFallback(registryPath, localRefs) {
+  let baseName = registryPath.replace(/\.[^.]+$/, ""), candidates = localRefs.filter((c) => c.registryPath.replace(/\.[^.]+$/, "") === baseName);
+  if (candidates.length === 1)
+    return logger.debug(`  Fallback match: ${registryPath} \u2192 ${candidates[0].registryPath} (same basename)`), candidates[0].registryPath;
+  let fileNameBase = (registryPath.split("/").pop() || "").replace(/\.[^.]+$/, "");
+  if (fileNameBase) {
+    let fileNameCandidates = localRefs.filter((c) => (c.registryPath.split("/").pop() || "").replace(/\.[^.]+$/, "") === fileNameBase);
+    if (fileNameCandidates.length === 1)
+      return logger.debug(
+        `  Fallback match: ${registryPath} \u2192 ${fileNameCandidates[0].registryPath} (same filename)`
+      ), fileNameCandidates[0].registryPath;
+  }
+  return null;
+}
+function findSourceFileForWorkspace(workspaceCandidate, localRefs, workspaceRoot) {
+  let platform = workspaceCandidate.platform;
+  if (!platform || platform === "ai")
+    return null;
+  try {
+    let platformExportFlows = getPlatformDefinition(platform, workspaceRoot).export || [], allExportFlows = [...getGlobalExportFlows(workspaceRoot) || [], ...platformExportFlows];
+    logger.debug(`  Checking ${allExportFlows.length} export flows for platform ${platform}`);
+    let workspacePath = workspaceCandidate.displayPath;
+    for (let flow of allExportFlows) {
+      let toPattern = Array.isArray(flow.to) ? flow.to[0] : flow.to;
+      if (typeof toPattern == "object" && "$switch" in toPattern || typeof toPattern != "string" || !minimatch(workspacePath, toPattern, { dot: !0 }))
+        continue;
+      logger.debug(`  Workspace path ${workspacePath} matches 'to' pattern: ${toPattern}`);
+      let fromPatterns = Array.isArray(flow.from) ? flow.from : [flow.from];
+      for (let fromPattern of fromPatterns)
+        if (!(typeof fromPattern == "object" && "$switch" in fromPattern) && typeof fromPattern == "string") {
+          logger.debug(`  Checking 'from' pattern: ${fromPattern}`);
+          for (let ref of localRefs)
+            if (minimatch(ref.registryPath, fromPattern, { dot: !0 }))
+              return logger.debug(`  Found matching source: ${ref.registryPath}`), ref.registryPath;
+        }
+    }
+    logger.debug("  No matching source file found");
+  } catch (error) {
+    logger.warn(`Failed to find source file for workspace candidate: ${error}`);
+  }
+  return null;
+}
+function filterGroupsWithWorkspace(groups) {
+  return groups.filter((group) => group.workspace.length > 0);
+}
+function ensureGroup(map, registryPath) {
+  let group = map.get(registryPath);
+  return group || (group = {
+    registryPath,
+    workspace: []
+  }, map.set(registryPath, group)), group;
+}
+
+// ../core/src/core/save/save-conversion-helper.ts
+import { join as join2 } from "path";
+import { tmpdir } from "os";
+import { mkdtemp, rm } from "fs/promises";
+import { minimatch as minimatch2 } from "minimatch";
+
+// ../core/src/core/save/save-merge-extractor.ts
+async function extractPackageContribution(candidate) {
+  if (candidate.source !== "workspace")
+    return {
+      success: !1,
+      error: "Extract only applies to workspace candidates"
+    };
+  if (!candidate.mergeStrategy || !candidate.mergeKeys || candidate.mergeKeys.length === 0)
+    return {
+      success: !1,
+      error: "No merge metadata present"
+    };
+  let { mergeStrategy, mergeKeys, content } = candidate;
+  try {
+    switch (mergeStrategy) {
+      case "deep":
+      case "shallow":
+        let normalizedKeys = normalizeKeysToParent(mergeKeys);
+        return await extractFromJsonMerge(content, normalizedKeys);
+      case "composite":
+        return {
+          success: !1,
+          error: "Composite merge extraction not yet implemented"
+        };
+      case "replace":
+        return {
+          success: !1,
+          error: "Replace strategy does not require extraction"
+        };
+      default:
+        return {
+          success: !1,
+          error: `Unknown merge strategy: ${mergeStrategy}`
+        };
+    }
+  } catch (error) {
+    return logger.debug(`Failed to extract package contribution: ${error}`), {
+      success: !1,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function extractContentByKeys(content, mergeKeys) {
+  try {
+    let normalizedKeys = normalizeKeysToParent(mergeKeys);
+    return await extractFromJsonMerge(content, normalizedKeys);
+  } catch (error) {
+    return {
+      success: !1,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function normalizeKeysToParent(keys) {
+  if (keys.length === 0) return [];
+  if (keys.every((key) => key.split(".").length <= 2))
+    return logger.debug(
+      "Keys already at parent level - using as-is",
+      { keys }
+    ), keys;
+  if (keys.length === 1) {
+    let parts = keys[0].split(".");
+    return parts.length >= 2 ? [parts.slice(0, 2).join(".")] : keys;
+  }
+  let firstParts = keys[0].split("."), commonDepth = 0;
+  for (let depth = 0; depth < firstParts.length; depth++) {
+    let segment = firstParts[depth];
+    if (keys.every((key) => {
+      let parts = key.split(".");
+      return parts.length > depth && parts[depth] === segment;
+    }))
+      commonDepth = depth + 1;
+    else
+      break;
+  }
+  let normalized = /* @__PURE__ */ new Set();
+  for (let key of keys) {
+    let parts = key.split("."), targetDepth = Math.max(2, commonDepth + 1), extractDepth = Math.min(targetDepth, parts.length);
+    extractDepth >= 2 ? normalized.add(parts.slice(0, extractDepth).join(".")) : parts.length > 0 && normalized.add(key);
+  }
+  let result = Array.from(normalized);
+  return logger.debug(
+    `Normalized ${keys.length} tracked keys to ${result.length} extraction key(s)`,
+    { original: keys, normalized: result }
+  ), result;
+}
+async function extractFromJsonMerge(content, mergeKeys) {
+  try {
+    let merged = JSON.parse(content), extracted = {};
+    for (let keyPath of mergeKeys) {
+      let value = getNestedValue(merged, keyPath);
+      value !== void 0 && setNestedValue(extracted, keyPath, value);
+    }
+    let extractedContent = JSON.stringify(extracted, null, 2) + `
+`, extractedHash = await calculateFileHash(extractedContent);
+    return logger.debug(
+      `Extracted ${mergeKeys.length} key(s) from merged file`,
+      { keys: mergeKeys }
+    ), {
+      success: !0,
+      extractedContent,
+      extractedHash
+    };
+  } catch (error) {
+    return {
+      success: !1,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function getNestedValue(obj, keyPath) {
+  let keys = keyPath.split("."), current = obj;
+  for (let key of keys) {
+    if (current == null || typeof current != "object")
+      return;
+    current = current[key];
+  }
+  return current;
+}
+function setNestedValue(obj, keyPath, value) {
+  let keys = keyPath.split("."), current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    let key = keys[i];
+    (!(key in current) || typeof current[key] != "object") && (current[key] = {}), current = current[key];
+  }
+  let lastKey = keys[keys.length - 1];
+  current[lastKey] = value;
+}
+
+// ../core/src/core/save/save-conversion-helper.ts
+var sharedTempDir = null, tempDirCounter = 0;
+async function initSharedTempDir() {
+  sharedTempDir || (sharedTempDir = await mkdtemp(join2(tmpdir(), "opkg-save-")));
+}
+async function cleanupSharedTempDir() {
+  if (sharedTempDir) {
+    try {
+      await rm(sharedTempDir, { recursive: !0, force: !0 });
+    } catch (error) {
+      logger.debug("Failed to cleanup shared temp directory", { tempDir: sharedTempDir, error });
+    }
+    sharedTempDir = null, tempDirCounter = 0;
+  }
+}
+async function allocateTempSubdir() {
+  if (!sharedTempDir)
+    return await mkdtemp(join2(tmpdir(), "opkg-save-standalone-"));
+  let subDir = join2(sharedTempDir, `op-${tempDirCounter++}`);
+  return await ensureDir(subDir), subDir;
+}
+var conversionCache = /* @__PURE__ */ new Map();
+function getCacheKey(candidate) {
+  return `${candidate.fullPath}:${candidate.contentHash}:${candidate.platform || "none"}`;
+}
+async function calculateConvertedHash(candidate, workspaceRoot) {
+  if (!candidate.platform || candidate.platform === "ai")
+    return candidate.contentHash;
+  let cacheKey = getCacheKey(candidate), cached = conversionCache.get(cacheKey);
+  if (cached)
+    return logger.debug(`Cache hit for converted hash: ${candidate.displayPath}`), cached;
+  let result = await convertWorkspaceToUniversal(
+    candidate.content,
+    candidate.platform,
+    candidate.registryPath,
+    workspaceRoot
+  );
+  return !result.success || !result.convertedHash ? (logger.debug(
+    `Conversion not applicable or failed for ${candidate.displayPath}, using raw hash`,
+    { reason: result.error }
+  ), candidate.contentHash) : (conversionCache.set(cacheKey, result.convertedHash), result.convertedHash);
+}
+async function convertWorkspaceToUniversal(workspaceContent, platform, registryPath, workspaceRoot) {
+  try {
+    let platformImportFlows = getPlatformDefinition(platform, workspaceRoot).import || [], allImportFlows = [...getGlobalImportFlows(workspaceRoot) || [], ...platformImportFlows];
+    if (allImportFlows.length === 0)
+      return logger.debug(`No import flows defined for platform ${platform}`), {
+        success: !1,
+        error: "No import flows defined for platform"
+      };
+    let matchingFlow = findMatchingImportFlow(
+      allImportFlows,
+      registryPath,
+      platform,
+      workspaceRoot
+    );
+    if (!matchingFlow)
+      return logger.debug(`No matching import flow for ${registryPath} on platform ${platform}`), {
+        success: !1,
+        error: "No matching import flow found"
+      };
+    let tempDir = await allocateTempSubdir(), inputDir = join2(tempDir, "in"), outputDir = join2(tempDir, "out");
+    await ensureDir(inputDir), await ensureDir(outputDir);
+    let workspaceSourcePath = inferWorkspaceSourcePath(
+      matchingFlow,
+      registryPath,
+      platform
+    ), inputFilePath = join2(inputDir, workspaceSourcePath);
+    await ensureDir(join2(inputFilePath, "..")), await writeTextFile(inputFilePath, workspaceContent);
+    let flowContext = {
+      workspaceRoot: outputDir,
+      // Output goes to outputDir
+      packageRoot: inputDir,
+      // Input comes from inputDir
+      platform,
+      // Source platform
+      packageName: "temp",
+      direction: "install",
+      // Import flows are used during "install" direction
+      variables: {
+        name: "temp",
+        version: "0.0.0",
+        platform,
+        // For conditionals: $$platform
+        source: platform,
+        // For conditionals: $$source
+        sourcePlatform: platform,
+        targetPlatform: "openpackage"
+      },
+      dryRun: !1
+    }, executor = createFlowExecutor(), concreteFlow = {
+      ...matchingFlow,
+      from: workspaceSourcePath
+      // Use concrete file path
+    }, flowResult = await executor.executeFlow(concreteFlow, flowContext);
+    if (!flowResult.success)
+      return {
+        success: !1,
+        error: `Flow execution failed: ${flowResult.error?.message}`
+      };
+    if (typeof flowResult.target != "string")
+      return {
+        success: !1,
+        error: "Flow did not produce target path"
+      };
+    let outputFilePath = flowResult.target;
+    if (!await exists(outputFilePath))
+      return {
+        success: !1,
+        error: "Flow did not produce output file"
+      };
+    let convertedContent = await readTextFile(outputFilePath), convertedHash = await calculateFileHash(convertedContent);
+    return logger.debug(
+      `Successfully converted ${registryPath} from ${platform} format to universal`,
+      {
+        originalHash: await calculateFileHash(workspaceContent),
+        convertedHash
+      }
+    ), {
+      success: !0,
+      convertedContent,
+      convertedHash
+    };
+  } catch (error) {
+    return logger.warn(
+      `Conversion failed for ${registryPath} (platform: ${platform})`,
+      { error }
+    ), {
+      success: !1,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function findMatchingImportFlow(flows, registryPath, platform, workspaceRoot) {
+  for (let flow of flows) {
+    let toPattern = Array.isArray(flow.to) ? flow.to[0] : flow.to;
+    if (typeof toPattern == "object" && "$switch" in toPattern) {
+      logger.debug("Skipping flow with switch expression in to field");
+      continue;
+    }
+    if (typeof toPattern == "string" && minimatch2(registryPath, toPattern, { dot: !0 })) {
+      if (flow.when && !evaluateWhenCondition(flow.when, platform, workspaceRoot)) {
+        logger.debug(`Flow condition not met for ${registryPath}`, { when: flow.when });
+        continue;
+      }
+      return flow;
+    }
+  }
+}
+function evaluateWhenCondition(when, platform, workspaceRoot) {
+  if (when.$eq && Array.isArray(when.$eq) && when.$eq.length === 2) {
+    let left = resolveVariable(when.$eq[0], platform), right = resolveVariable(when.$eq[1], platform);
+    return left === right;
+  }
+  if (when.$ne && Array.isArray(when.$ne) && when.$ne.length === 2) {
+    let left = resolveVariable(when.$ne[0], platform), right = resolveVariable(when.$ne[1], platform);
+    return left !== right;
+  }
+  return when.exists ? !0 : (logger.debug("Unknown condition type in when clause", { when }), !1);
+}
+function resolveVariable(value, platform) {
+  return typeof value == "string" && (value === "$$platform" || value === "$$source") ? platform : value;
+}
+function inferWorkspaceSourcePath(flow, registryPath, platform) {
+  let fromPattern = Array.isArray(flow.from) ? flow.from[0] : flow.from;
+  if (typeof fromPattern == "object" && "$switch" in fromPattern)
+    return logger.debug("Cannot infer source path from switch expression, using registry path"), registryPath;
+  if (typeof fromPattern != "string")
+    return registryPath;
+  if (fromPattern.includes("**") || fromPattern.includes("*")) {
+    let baseDir = fromPattern.split("**")[0].replace(/\*+/g, ""), toPattern = Array.isArray(flow.to) ? flow.to[0] : flow.to;
+    if (typeof toPattern == "string" && toPattern.includes("**")) {
+      let toBase = toPattern.split("**")[0], subPath = registryPath.startsWith(toBase) ? registryPath.slice(toBase.length) : registryPath;
+      return `${baseDir}${subPath}`;
+    }
+    return registryPath;
+  }
+  return fromPattern;
+}
+async function convertSourceToWorkspace(sourceContent, platform, sourceRegistryPath, workspacePath, workspaceRoot) {
+  try {
+    let platformExportFlows = getPlatformDefinition(platform, workspaceRoot).export || [], allExportFlows = [...getGlobalExportFlows(workspaceRoot) || [], ...platformExportFlows];
+    if (allExportFlows.length === 0)
+      return {
+        success: !1,
+        error: "No export flows defined for platform"
+      };
+    let matchingFlow = findMatchingExportFlow(
+      allExportFlows,
+      sourceRegistryPath,
+      workspacePath,
+      platform,
+      workspaceRoot
+    );
+    if (!matchingFlow)
+      return {
+        success: !1,
+        error: "No matching export flow found"
+      };
+    let tempDir = await allocateTempSubdir(), inputDir = join2(tempDir, "in"), outputDir = join2(tempDir, "out");
+    await ensureDir(inputDir), await ensureDir(outputDir);
+    let inputFilePath = join2(inputDir, sourceRegistryPath);
+    await ensureDir(join2(inputFilePath, "..")), await writeTextFile(inputFilePath, sourceContent);
+    let flowContext = {
+      workspaceRoot: outputDir,
+      // Output goes to outputDir
+      packageRoot: inputDir,
+      // Input comes from inputDir
+      platform,
+      packageName: "temp",
+      direction: "install",
+      // Export flows are used during "install" direction
+      variables: {
+        name: "temp",
+        version: "0.0.0",
+        platform,
+        source: "openpackage",
+        sourcePlatform: "openpackage",
+        targetPlatform: platform,
+        targetRoot: "./"
+      },
+      dryRun: !1
+    }, flowResult = await createFlowExecutor().executeFlow(matchingFlow, flowContext);
+    if (!flowResult.success)
+      return {
+        success: !1,
+        error: `Flow execution failed: ${flowResult.error?.message}`
+      };
+    if (typeof flowResult.target != "string")
+      return {
+        success: !1,
+        error: "Flow did not produce target path"
+      };
+    let outputFilePath = flowResult.target;
+    if (!await exists(outputFilePath))
+      return {
+        success: !1,
+        error: "Flow did not produce output file"
+      };
+    let convertedContent = await readTextFile(outputFilePath), convertedHash = await calculateFileHash(convertedContent);
+    return logger.debug(
+      `Successfully forward converted ${sourceRegistryPath} to ${platform} format`,
+      {
+        originalHash: await calculateFileHash(sourceContent),
+        convertedHash
+      }
+    ), {
+      success: !0,
+      convertedContent,
+      convertedHash
+    };
+  } catch (error) {
+    return logger.warn(
+      `Forward conversion failed for ${sourceRegistryPath} (platform: ${platform})`,
+      { error }
+    ), {
+      success: !1,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function findMatchingExportFlow(flows, sourceRegistryPath, workspacePath, platform, workspaceRoot) {
+  for (let flow of flows) {
+    let fromPatterns = Array.isArray(flow.from) ? flow.from : [flow.from];
+    if (!(fromPatterns.some((p) => typeof p == "object" && "$switch" in p) || fromPatterns.some((p) => typeof p != "string") || !fromPatterns.some(
+      (p) => typeof p == "string" && minimatch2(sourceRegistryPath, p, { dot: !0 })
+    )) && !(flow.when && !evaluateWhenCondition(flow.when, platform, workspaceRoot)))
+      return flow;
+  }
+}
+async function ensureComparableHash(candidate, workspaceRoot) {
+  if (candidate.comparableHash !== void 0)
+    return candidate.comparableHash;
+  let hash = candidate.contentHash;
+  if (candidate.mergeStrategy && candidate.mergeKeys && candidate.mergeKeys.length > 0) {
+    let extractResult = await extractPackageContribution(candidate);
+    extractResult.success && extractResult.extractedHash ? (hash = extractResult.extractedHash, extractResult.extractedContent && (candidate.extractedContent = extractResult.extractedContent)) : hash = await calculateConvertedHash(candidate, workspaceRoot);
+  } else
+    hash = await calculateConvertedHash(candidate, workspaceRoot);
+  return candidate.comparableHash = hash, hash;
+}
+function clearConversionCache() {
+  conversionCache.clear();
+}
+
+// ../core/src/core/save/save-conflict-analyzer.ts
+async function analyzeGroup(group, force, workspaceRoot) {
+  let registryPath = group.registryPath, hasLocal = !!group.local, workspaceCandidates = group.workspace, workspaceCandidateCount = workspaceCandidates.length, isRootFile = registryPath === FILE_PATTERNS.AGENTS_MD || registryPath === FILE_PATTERNS.CLAUDE_MD || registryPath === FILE_PATTERNS.GEMINI_MD || registryPath === FILE_PATTERNS.QWEN_MD || registryPath === FILE_PATTERNS.WARP_MD || workspaceCandidates.some((c) => c.isRootFile), hasPlatformCandidates = workspaceCandidates.some(
+    (c) => c.platform && c.platform !== "ai"
+  );
+  if (workspaceCandidateCount === 0)
+    return {
+      registryPath,
+      type: "no-action-needed",
+      workspaceCandidateCount: 0,
+      uniqueWorkspaceCandidates: [],
+      hasLocalCandidate: hasLocal,
+      localMatchesWorkspace: !1,
+      isRootFile,
+      hasPlatformCandidates: !1,
+      recommendedStrategy: "skip"
+    };
+  let uniqueWorkspace = await deduplicateCandidatesWithMerge(workspaceCandidates, workspaceRoot), localMatchesWorkspace = hasLocal && uniqueWorkspace.length === 1 ? await checkConvertedParity(uniqueWorkspace[0], group.local, workspaceRoot) : !1;
+  return hasLocal && uniqueWorkspace.length > 1 && (await Promise.all(
+    uniqueWorkspace.map(async (candidate) => ({
+      workspacePath: candidate.displayPath,
+      platform: candidate.platform || "none",
+      matchesLocal: await checkConvertedParity(candidate, group.local, workspaceRoot)
+    }))
+  )).every((result) => result.matchesLocal) ? {
+    registryPath,
+    type: "no-change-needed",
+    workspaceCandidateCount,
+    uniqueWorkspaceCandidates: uniqueWorkspace,
+    hasLocalCandidate: hasLocal,
+    localMatchesWorkspace: !0,
+    isRootFile,
+    hasPlatformCandidates,
+    recommendedStrategy: "skip"
+  } : localMatchesWorkspace ? {
+    registryPath,
+    type: "no-change-needed",
+    workspaceCandidateCount,
+    uniqueWorkspaceCandidates: uniqueWorkspace,
+    hasLocalCandidate: hasLocal,
+    localMatchesWorkspace: !0,
+    isRootFile,
+    hasPlatformCandidates,
+    recommendedStrategy: "skip"
+  } : uniqueWorkspace.length === 1 ? {
+    registryPath,
+    type: "auto-write",
+    workspaceCandidateCount,
+    uniqueWorkspaceCandidates: uniqueWorkspace,
+    hasLocalCandidate: hasLocal,
+    localMatchesWorkspace: !1,
+    isRootFile,
+    hasPlatformCandidates,
+    recommendedStrategy: "write-single"
+  } : {
+    registryPath,
+    type: "needs-resolution",
+    workspaceCandidateCount,
+    uniqueWorkspaceCandidates: uniqueWorkspace,
+    hasLocalCandidate: hasLocal,
+    localMatchesWorkspace: !1,
+    isRootFile,
+    hasPlatformCandidates,
+    recommendedStrategy: force ? "force-newest" : "interactive"
+  };
+}
+async function checkConvertedParity(workspace, local, workspaceRoot) {
+  let workspaceHash = await ensureComparableHash(workspace, workspaceRoot);
+  if (workspace.mergeStrategy && workspace.mergeKeys && workspace.mergeKeys.length > 0) {
+    if (workspace.platform && workspace.platform !== "ai") {
+      let forward = await convertSourceToWorkspace(
+        local.content,
+        workspace.platform,
+        local.registryPath,
+        workspace.displayPath,
+        workspaceRoot
+      );
+      if (forward.success && forward.convertedContent) {
+        let localConvertedExtract = await extractContentByKeys(
+          forward.convertedContent,
+          workspace.mergeKeys
+        );
+        if (localConvertedExtract.success && localConvertedExtract.extractedHash)
+          return workspaceHash === localConvertedExtract.extractedHash;
+      }
+    }
+    let localExtract = await extractContentByKeys(local.content, workspace.mergeKeys);
+    return localExtract.success && localExtract.extractedHash ? workspaceHash === localExtract.extractedHash : workspaceHash === local.contentHash;
+  }
+  return workspaceHash === local.contentHash;
+}
+async function deduplicateCandidatesWithMerge(candidates, workspaceRoot) {
+  let seen = /* @__PURE__ */ new Set(), unique = [];
+  for (let candidate of candidates) {
+    let hash = await ensureComparableHash(candidate, workspaceRoot);
+    if (logger.debug(
+      `Dedup check for ${candidate.displayPath}: hash=${hash}, rawHash=${candidate.contentHash}, seen=${seen.has(hash)}`
+    ), seen.has(hash)) {
+      logger.debug(`  Skipping duplicate: ${candidate.displayPath}`);
+      continue;
+    }
+    seen.add(hash), unique.push(candidate);
+  }
+  return logger.debug(`Deduplication: ${candidates.length} \u2192 ${unique.length} unique candidates`), unique;
+}
+function getNewestCandidate(candidates) {
+  if (candidates.length === 0)
+    throw new Error("Cannot get newest candidate from empty array");
+  if (candidates.length === 1)
+    return candidates[0];
+  let newest = candidates[0];
+  for (let i = 1; i < candidates.length; i++) {
+    let current = candidates[i];
+    (current.mtime > newest.mtime || current.mtime === newest.mtime && current.displayPath < newest.displayPath) && (newest = current);
+  }
+  return newest;
+}
+function sortCandidatesByMtime(candidates) {
+  return [...candidates].sort((a, b) => b.mtime !== a.mtime ? b.mtime - a.mtime : a.displayPath.localeCompare(b.displayPath));
+}
+
+// ../core/src/core/save/save-interactive-resolver.ts
+import { join as join3 } from "path";
+
+// ../core/src/core/platform/platform-specific-paths.ts
+function joinSegments(segments) {
+  return segments.filter(Boolean).join("/");
+}
+function suffixFileBasename(registryPath, platform) {
+  let segments = registryPath.split("/"), fileName = segments.pop();
+  if (!fileName)
+    return registryPath;
+  let lastDotIndex = fileName.lastIndexOf(".");
+  if (lastDotIndex <= 0)
+    return fileName.endsWith(`.${platform}`) ? segments.push(fileName) : segments.push(`${fileName}.${platform}`), joinSegments(segments);
+  let name = fileName.slice(0, lastDotIndex), ext = fileName.slice(lastDotIndex);
+  return name.endsWith(`.${platform}`) ? (segments.push(fileName), joinSegments(segments)) : (segments.push(`${name}.${platform}${ext}`), joinSegments(segments));
+}
+function createPlatformSpecificRegistryPath(registryPath, platform) {
+  let segments = registryPath.split("/"), fileName = segments[segments.length - 1], isRoot = segments.length === 1;
+  if (!fileName)
+    return registryPath;
+  if (isRoot) {
+    let definition = getPlatformDefinition(platform);
+    return definition?.rootFile ? definition.rootFile : null;
+  }
+  return registryPath.endsWith(FILE_PATTERNS.MD_FILES), suffixFileBasename(registryPath, platform);
+}
+
+// ../core/src/core/save/save-interactive-resolver.ts
+async function resolveInteractively(input, output, prompt) {
+  let { registryPath, workspaceCandidates, group, packageRoot, workspaceRoot } = input, out = output ?? resolveOutput(), prm = prompt ?? resolvePrompt(), sortedCandidates = sortCandidatesByMtime(workspaceCandidates);
+  displayConflictHeader(registryPath, sortedCandidates, out);
+  let universalSelected = null, platformSpecificCandidates = [], skippedCandidates = [];
+  for (let candidate of sortedCandidates) {
+    let parityCheck = await isAtParity(candidate, group, packageRoot, workspaceRoot);
+    if (parityCheck.atParity) {
+      out.info(`
+  \u2713 ${candidate.displayPath}`), out.info(`    ${parityCheck.reason} - auto-skipping
+`), skippedCandidates.push(candidate);
+      continue;
+    }
+    if (universalSelected) {
+      let universalHash = await ensureComparableHash(universalSelected, workspaceRoot);
+      if (await ensureComparableHash(candidate, workspaceRoot) === universalHash) {
+        out.info(`
+  \u2713 ${candidate.displayPath}`), out.info(`    Identical to universal - auto-skipping
+`), skippedCandidates.push(candidate);
+        continue;
+      }
+    }
+    switch (await promptCandidateAction(
+      candidate,
+      registryPath,
+      universalSelected !== null,
+      prm
+    )) {
+      case "universal":
+        universalSelected = candidate, out.success(`
+  \u2713 Selected as universal: ${candidate.displayPath}
+`);
+        break;
+      case "platform-specific":
+        platformSpecificCandidates.push(candidate), out.success(`
+  \u2713 Marked as platform-specific: ${candidate.displayPath}
+`);
+        break;
+      case "skip":
+        skippedCandidates.push(candidate), out.info(`
+  \u2713 Skipped: ${candidate.displayPath}
+`);
+        break;
+    }
+  }
+  return displayResolutionSummary(universalSelected, platformSpecificCandidates, skippedCandidates, out), {
+    selectedCandidate: universalSelected,
+    platformSpecificCandidates
+  };
+}
+async function checkForwardParity(workspaceCandidate, localCandidate, packageRoot, workspaceRoot) {
+  try {
+    let result = await convertSourceToWorkspace(
+      localCandidate.content,
+      workspaceCandidate.platform,
+      localCandidate.registryPath,
+      workspaceCandidate.displayPath,
+      workspaceRoot
+    );
+    if (result.success && result.convertedHash && (logger.debug(
+      `Forward conversion check: converted source hash=${result.convertedHash}, workspace hash=${workspaceCandidate.contentHash}`
+    ), result.convertedHash === workspaceCandidate.contentHash))
+      return {
+        atParity: !0,
+        reason: "Matches source after forward conversion (export flow)"
+      };
+  } catch (error) {
+    logger.debug(`Forward parity check failed: ${error}`);
+  }
+  return { atParity: !1 };
+}
+async function isAtParity(candidate, group, packageRoot, workspaceRoot) {
+  if (group.local) {
+    let comparisonHash = await ensureComparableHash(candidate, workspaceRoot);
+    if (logger.debug(
+      `Parity check for ${candidate.displayPath}: comparisonHash=${comparisonHash}, localHash=${group.local.contentHash}`
+    ), comparisonHash === group.local.contentHash)
+      return {
+        atParity: !0,
+        reason: "Already matches universal (cached comparable hash)"
+      };
+    if (candidate.platform && candidate.platform !== "ai" && !(candidate.mergeStrategy && candidate.mergeKeys && candidate.mergeKeys.length > 0)) {
+      let forwardCheck = await checkForwardParity(
+        candidate,
+        group.local,
+        packageRoot,
+        workspaceRoot
+      );
+      if (forwardCheck.atParity)
+        return forwardCheck;
+    }
+  }
+  if (candidate.platform && candidate.platform !== "ai") {
+    let platformPath = createPlatformSpecificRegistryPath(
+      group.registryPath,
+      candidate.platform
+    );
+    if (platformPath) {
+      let platformFullPath = join3(packageRoot, platformPath);
+      if (await exists(platformFullPath))
+        try {
+          let platformContent = await readTextFile(platformFullPath), platformHash = await calculateFileHash(platformContent);
+          if (candidate.contentHash === platformHash)
+            return {
+              atParity: !0,
+              reason: "Already matches platform-specific file"
+            };
+        } catch (error) {
+          logger.debug(`Could not read platform file ${platformFullPath}: ${error}`);
+        }
+    }
+  }
+  return { atParity: !1 };
+}
+async function promptCandidateAction(candidate, registryPath, universalAlreadySelected, prm) {
+  let candidateLabel = formatCandidateLabel(candidate, !0), choices = universalAlreadySelected ? [
+    { title: "Mark as platform-specific", value: "platform-specific" },
+    { title: "Skip", value: "skip" }
+  ] : [
+    { title: "Set as universal", value: "universal" },
+    { title: "Mark as platform-specific", value: "platform-specific" },
+    { title: "Skip", value: "skip" }
+  ];
+  return await prm.select(
+    `  ${candidateLabel}
+  What should we do with this file?`,
+    choices,
+    "Arrow keys to navigate, Enter to select"
+  );
+}
+function displayConflictHeader(registryPath, candidates, out) {
+  out.warn(`Multiple workspace versions found for ${registryPath}`), out.info(`   Resolving conflicts for ${candidates.length} file(s)...
+`);
+}
+function displayResolutionSummary(universal, platformSpecific, skipped, out) {
+  out.info("\u2500".repeat(60)), out.info("Resolution summary:"), universal ? out.success(`  \u2713 Universal: ${universal.displayPath}`) : out.info("  \u2139 No universal content selected"), platformSpecific.length > 0 && (out.success(`  \u2713 Platform-specific: ${platformSpecific.length} file(s)`), platformSpecific.forEach((c) => {
+    let platform = c.platform ? `(${c.platform})` : "";
+    out.info(`    \u2022 ${c.displayPath} ${platform}`);
+  })), skipped.length > 0 && out.info(`  \u2022 Skipped: ${skipped.length} file(s)`), out.info("\u2500".repeat(60) + `
+`);
+}
+function formatCandidateLabel(candidate, includeTimestamp = !1) {
+  let parts = [];
+  if (parts.push(candidate.displayPath), candidate.platform && candidate.platform !== "ai" && parts.push(`(${candidate.platform})`), includeTimestamp) {
+    let timestamp = new Date(candidate.mtime).toLocaleString();
+    parts.push(`[${timestamp}]`);
+  }
+  return parts.join(" ");
+}
+
+// ../core/src/core/save/save-resolution-executor.ts
+async function executeResolution(group, analysis, packageRoot, workspaceRoot, output, prompt) {
+  let strategy = analysis.recommendedStrategy;
+  if (strategy === "skip")
+    return null;
+  let sortedCandidates = sortCandidatesByMtime(analysis.uniqueWorkspaceCandidates);
+  switch (strategy) {
+    case "write-single":
+      return resolveSingle(sortedCandidates[0]);
+    case "write-newest":
+      return resolveIdentical(sortedCandidates);
+    case "force-newest":
+      return resolveForce(sortedCandidates, group.registryPath);
+    case "interactive":
+      return resolveInteractive(
+        group.registryPath,
+        sortedCandidates,
+        analysis.isRootFile,
+        group,
+        packageRoot,
+        workspaceRoot,
+        output,
+        prompt
+      );
+    default:
+      return logger.warn(`Unknown resolution strategy: ${strategy}`), null;
+  }
+}
+function resolveSingle(candidate) {
+  return {
+    selection: candidate,
+    platformSpecific: [],
+    strategy: "write-single",
+    wasInteractive: !1
+  };
+}
+function resolveIdentical(candidates) {
+  return {
+    selection: getNewestCandidate(candidates),
+    platformSpecific: [],
+    strategy: "write-newest",
+    wasInteractive: !1
+  };
+}
+function resolveForce(candidates, registryPath) {
+  let newest = getNewestCandidate(candidates), maxMtime = newest.mtime, tiedCandidates = candidates.filter((c) => c.mtime === maxMtime);
+  if (tiedCandidates.length > 1)
+    logger.info(
+      `Force mode: Multiple files have same modification time (${formatTimestamp(maxMtime)})`
+    ), logger.info(`  Auto-selecting first alphabetically: ${newest.displayPath}`), logger.info("  Tied files:"), tiedCandidates.forEach((c) => {
+      let marker = c === newest ? "\u2192" : " ";
+      logger.info(`    ${marker} ${c.displayPath}`);
+    }), tiedCandidates.filter((c) => c !== newest).forEach((c) => {
+      logger.info(`  Skipping: ${c.displayPath} (tied, not alphabetically first)`);
+    }), candidates.filter((c) => c.mtime < maxMtime).forEach((c) => {
+      logger.info(`  Skipping: ${c.displayPath} (older)`);
+    });
+  else {
+    logger.info(`Force mode: Auto-selecting newest (${newest.displayPath})`);
+    let skipped = candidates.filter((c) => c !== newest);
+    skipped.length > 0 && skipped.forEach((c) => {
+      logger.info(`  Skipping: ${c.displayPath} (older)`);
+    });
+  }
+  return {
+    selection: newest,
+    platformSpecific: [],
+    // Force mode doesn't auto-create platform-specific variants
+    strategy: "force-newest",
+    wasInteractive: !1
+  };
+}
+async function resolveInteractive(registryPath, candidates, isRootFile, group, packageRoot, workspaceRoot, output, prompt) {
+  let result = await resolveInteractively({
+    registryPath,
+    workspaceCandidates: candidates,
+    isRootFile,
+    group,
+    packageRoot,
+    workspaceRoot
+  }, output, prompt);
+  return {
+    selection: result.selectedCandidate,
+    platformSpecific: result.platformSpecificCandidates,
+    strategy: "interactive",
+    wasInteractive: !0
+  };
+}
+function formatTimestamp(mtime) {
+  return new Date(mtime).toLocaleString();
+}
+
+// ../core/src/core/save/save-platform-handler.ts
+import { join as join4 } from "path";
+async function pruneExistingPlatformCandidates(packageRoot, groups) {
+  for (let group of groups) {
+    if (!group.local && !group.localRef)
+      continue;
+    let filtered = [];
+    for (let candidate of group.workspace) {
+      let platform = candidate.platform;
+      if (!platform || platform === "ai") {
+        filtered.push(candidate);
+        continue;
+      }
+      let platformPath = createPlatformSpecificRegistryPath(
+        group.registryPath,
+        platform
+      );
+      if (!platformPath) {
+        filtered.push(candidate);
+        continue;
+      }
+      let platformFullPath = join4(packageRoot, platformPath);
+      if (await exists(platformFullPath)) {
+        logger.debug(
+          `Pruning workspace candidate ${candidate.displayPath} for ${group.registryPath} (platform file ${platformPath} exists in source)`
+        );
+        continue;
+      }
+      filtered.push(candidate);
+    }
+    group.workspace = filtered;
+  }
+}
+
+// ../core/src/core/save/save-write-coordinator.ts
+import { dirname, join as join5 } from "path";
+import { minimatch as minimatch3 } from "minimatch";
+async function writeResolution(packageRoot, registryPath, resolution, localCandidate, workspaceRoot) {
+  let results = [];
+  if (resolution.selection) {
+    let universalResult = await writeUniversal(
+      packageRoot,
+      registryPath,
+      resolution.selection,
+      localCandidate,
+      workspaceRoot
+    );
+    results.push(universalResult);
+  } else
+    logger.debug(`No universal content selected for ${registryPath} - keeping original untouched`);
+  for (let platformCandidate of resolution.platformSpecific) {
+    let platformResult = await writePlatformSpecific(
+      packageRoot,
+      registryPath,
+      platformCandidate,
+      workspaceRoot
+    );
+    results.push(platformResult);
+  }
+  return results;
+}
+async function writeUniversal(packageRoot, registryPath, candidate, localCandidate, workspaceRoot) {
+  let targetPath = join5(packageRoot, registryPath), preparedContent = await prepareContentForWrite(candidate, registryPath, workspaceRoot), writeDecision = shouldWrite(candidate, localCandidate, preparedContent.content), operation = {
+    registryPath,
+    targetPath,
+    content: preparedContent.content,
+    operation: writeDecision.operation,
+    isPlatformSpecific: !1
+  };
+  if (!writeDecision.needed)
+    return logger.debug(`Skipping write for ${registryPath}: content identical to source`), {
+      operation,
+      success: !0
+    };
+  let writeResult = await safeWrite(targetPath, preparedContent.content);
+  if (writeResult.success) {
+    let action = operation.operation === "create" ? "Created" : "Updated";
+    logger.debug(`${action} ${registryPath}${preparedContent.wasExtracted ? " (extracted package contribution)" : ""}`);
+  }
+  return {
+    operation,
+    success: writeResult.success,
+    error: writeResult.error
+  };
+}
+async function writePlatformSpecific(packageRoot, registryPath, candidate, workspaceRoot) {
+  let platform = candidate.platform;
+  if (!platform || platform === "ai")
+    return {
+      operation: {
+        registryPath,
+        targetPath: "",
+        content: "",
+        operation: "skip",
+        isPlatformSpecific: !0
+      },
+      success: !1,
+      error: new Error("Candidate has no platform association")
+    };
+  let platformRegistryPath = createPlatformSpecificRegistryPath(registryPath, platform);
+  if (!platformRegistryPath)
+    return {
+      operation: {
+        registryPath,
+        targetPath: "",
+        content: "",
+        operation: "skip",
+        isPlatformSpecific: !0,
+        platform
+      },
+      success: !1,
+      error: new Error(`Could not create platform-specific path for ${platform}`)
+    };
+  let targetPath = join5(packageRoot, platformRegistryPath), preparedContent = await prepareContentForWrite(candidate, platformRegistryPath, workspaceRoot), fileExists = await exists(targetPath), operationType = fileExists ? "update" : "create", operation = {
+    registryPath: platformRegistryPath,
+    targetPath,
+    content: preparedContent.content,
+    operation: operationType,
+    isPlatformSpecific: !0,
+    platform
+  };
+  if (fileExists)
+    try {
+      if (await readTextFile(targetPath) === preparedContent.content)
+        return logger.debug(`Skipping write for ${platformRegistryPath}: content identical`), operation.operation = "skip", {
+          operation,
+          success: !0
+        };
+    } catch (error) {
+      logger.debug(`Could not read existing file ${platformRegistryPath}: ${error}`);
+    }
+  let writeResult = await safeWrite(targetPath, preparedContent.content);
+  if (writeResult.success) {
+    let action = operationType === "create" ? "Created" : "Updated";
+    logger.debug(
+      `${action} platform-specific file: ${platformRegistryPath}${preparedContent.wasExtracted ? " (extracted package contribution)" : ""}`
+    );
+  }
+  return {
+    operation,
+    success: writeResult.success,
+    error: writeResult.error
+  };
+}
+async function applyImportTransformation(content, platform, registryPath, workspacePath, workspaceRoot) {
+  try {
+    let platformImportFlows = getPlatformDefinition(platform, workspaceRoot).import || [], allImportFlows = [...getGlobalImportFlows(workspaceRoot) || [], ...platformImportFlows];
+    if (allImportFlows.length === 0)
+      return {
+        success: !1,
+        reason: "No import flows defined for platform"
+      };
+    let matchingFlow = findMatchingFlow(
+      allImportFlows,
+      workspacePath,
+      registryPath,
+      platform,
+      workspaceRoot
+    );
+    if (!matchingFlow)
+      return {
+        success: !1,
+        reason: "No matching import flow found"
+      };
+    if (!matchingFlow.map || matchingFlow.map.length === 0)
+      return {
+        success: !1,
+        reason: "Flow has no map operations"
+      };
+    let tempDir = await allocateTempSubdir(), inputDir = join5(tempDir, "in"), outputDir = join5(tempDir, "out");
+    await ensureDir(inputDir), await ensureDir(outputDir);
+    let inputFileName = registryPath.split("/").pop() || "file.json", inputFilePath = join5(inputDir, inputFileName);
+    await writeTextFile(inputFilePath, content);
+    let flowContext = {
+      workspaceRoot: outputDir,
+      packageRoot: inputDir,
+      platform,
+      packageName: "temp",
+      direction: "install",
+      // Import flows run during install
+      variables: {
+        name: "temp",
+        version: "0.0.0",
+        platform,
+        source: platform,
+        sourcePlatform: platform,
+        targetPlatform: "openpackage"
+      },
+      dryRun: !1
+    }, executor = createFlowExecutor(), concreteFlow = {
+      ...matchingFlow,
+      from: inputFileName
+    }, flowResult = await executor.executeFlow(concreteFlow, flowContext);
+    if (!flowResult.success)
+      return {
+        success: !1,
+        reason: `Flow execution failed: ${flowResult.error?.message}`
+      };
+    if (typeof flowResult.target != "string")
+      return {
+        success: !1,
+        reason: "Flow did not produce target path"
+      };
+    let outputFilePath = flowResult.target;
+    if (!await exists(outputFilePath))
+      return {
+        success: !1,
+        reason: "Flow did not produce output file"
+      };
+    let transformedContent = await readTextFile(outputFilePath);
+    return logger.debug(
+      `Successfully transformed extracted content from ${platform} format to universal`,
+      { registryPath }
+    ), {
+      success: !0,
+      transformedContent
+    };
+  } catch (error) {
+    return logger.debug(
+      `Import transformation failed for ${registryPath} (platform: ${platform})`,
+      { error }
+    ), {
+      success: !1,
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function findMatchingFlow(flows, workspacePath, registryPath, platform, workspaceRoot) {
+  let registryPathCandidates = getRegistryPathCandidates(registryPath);
+  for (let flow of flows) {
+    let fromPatterns = Array.isArray(flow.from) ? flow.from : [flow.from], matchesFrom = !1;
+    for (let fromPattern of fromPatterns) {
+      if (typeof fromPattern == "object" && "$switch" in fromPattern) {
+        let defaultValue = fromPattern.$switch?.default;
+        if (typeof defaultValue == "string" && minimatch3(workspacePath, defaultValue, { dot: !0 })) {
+          matchesFrom = !0;
+          break;
+        }
+        continue;
+      }
+      if (typeof fromPattern == "string" && minimatch3(workspacePath, fromPattern, { dot: !0 })) {
+        matchesFrom = !0;
+        break;
+      }
+    }
+    if (!matchesFrom)
+      continue;
+    let toPattern = Array.isArray(flow.to) ? flow.to[0] : flow.to;
+    if (typeof toPattern == "object" && "$switch" in toPattern) {
+      logger.debug("Skipping flow with switch expression in to field");
+      continue;
+    }
+    if (!(typeof toPattern != "string" || !registryPathCandidates.some(
+      (candidatePath) => minimatch3(candidatePath, toPattern, { dot: !0 })
+    ))) {
+      if (flow.when && !evaluateWhenCondition2(flow.when, platform)) {
+        logger.debug(`Flow condition not met for ${registryPath}`, { when: flow.when });
+        continue;
+      }
+      return logger.debug(
+        `Matched import flow: from=${workspacePath} to=${registryPath}`,
+        { platform }
+      ), flow;
+    }
+  }
+  logger.debug(
+    "No matching import flow found",
+    { workspacePath, registryPath, platform, flowCount: flows.length }
+  );
+}
+function getRegistryPathCandidates(registryPath) {
+  let candidates = [registryPath];
+  return registryPath.endsWith(".jsonc") ? candidates.push(registryPath.replace(/\.jsonc$/, ".json")) : registryPath.endsWith(".json") && candidates.push(registryPath.replace(/\.json$/, ".jsonc")), candidates;
+}
+function evaluateWhenCondition2(when, platform) {
+  if (when.$eq && Array.isArray(when.$eq) && when.$eq.length === 2) {
+    let left = resolveVariable2(when.$eq[0], platform), right = resolveVariable2(when.$eq[1], platform);
+    return left === right;
+  }
+  if (when.$ne && Array.isArray(when.$ne) && when.$ne.length === 2) {
+    let left = resolveVariable2(when.$ne[0], platform), right = resolveVariable2(when.$ne[1], platform);
+    return left !== right;
+  }
+  return when.exists ? !0 : (logger.debug("Unknown condition type in when clause", { when }), !1);
+}
+function resolveVariable2(value, platform) {
+  return typeof value == "string" && (value === "$$platform" || value === "$$source") ? platform : value;
+}
+async function prepareContentForWrite(candidate, registryPath, workspaceRoot) {
+  if (!!!(candidate.source === "workspace" && candidate.mergeStrategy && candidate.mergeKeys && candidate.mergeKeys.length > 0))
+    return { content: candidate.content, wasExtracted: !1 };
+  logger.debug(
+    `Extracting package contribution from merged file: ${registryPath}`,
+    {
+      strategy: candidate.mergeStrategy,
+      keyCount: candidate.mergeKeys.length,
+      platform: candidate.platform
+    }
+  );
+  let extractResult = await extractPackageContribution(candidate);
+  if (extractResult.success && extractResult.extractedContent) {
+    logger.info(
+      `Successfully extracted package contribution for ${registryPath} (${candidate.mergeKeys.length} key(s))`
+    );
+    let finalContent = extractResult.extractedContent;
+    if (candidate.platform && candidate.platform !== "ai" && workspaceRoot) {
+      logger.info(
+        "Attempting import transformation for merged file",
+        {
+          platform: candidate.platform,
+          registryPath,
+          displayPath: candidate.displayPath,
+          hasWorkspaceRoot: !!workspaceRoot
+        }
+      );
+      let transformResult = await applyImportTransformation(
+        extractResult.extractedContent,
+        candidate.platform,
+        registryPath,
+        candidate.displayPath,
+        workspaceRoot
+      );
+      transformResult.success && transformResult.transformedContent ? (logger.info(
+        `Successfully applied import transformation for platform ${candidate.platform}`,
+        { registryPath }
+      ), finalContent = transformResult.transformedContent) : logger.warn(
+        `Import transformation failed or not applicable: ${transformResult.reason}`,
+        { registryPath, platform: candidate.platform }
+      );
+    } else
+      logger.debug(
+        "Skipping import transformation",
+        {
+          hasPlatform: !!candidate.platform,
+          platform: candidate.platform,
+          hasWorkspaceRoot: !!workspaceRoot
+        }
+      );
+    return {
+      content: finalContent,
+      wasExtracted: !0
+    };
+  }
+  return logger.warn(
+    `Failed to extract package contribution from merged file: ${registryPath}`,
+    {
+      reason: extractResult.error,
+      fallback: "Using full content"
+    }
+  ), logger.warn(
+    `\u26A0\uFE0F  Writing full merged content to ${registryPath} - this may include keys from other packages or base workspace content`
+  ), { content: candidate.content, wasExtracted: !1 };
+}
+function shouldWrite(candidate, localCandidate, preparedContent) {
+  return localCandidate ? preparedContent && preparedContent !== candidate.content ? preparedContent === localCandidate.content ? { needed: !1, operation: "skip" } : { needed: !0, operation: "update" } : candidate.contentHash === localCandidate.contentHash ? { needed: !1, operation: "skip" } : { needed: !0, operation: "update" } : { needed: !0, operation: "create" };
+}
+async function safeWrite(targetPath, content) {
+  try {
+    return await ensureDir(dirname(targetPath)), await writeTextFile(targetPath, content), { success: !0 };
+  } catch (error) {
+    return logger.error(`Failed to write file ${targetPath}: ${error}`), {
+      success: !1,
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+}
+
+// ../core/src/core/save/save-result-reporter.ts
+function buildSaveReport(packageName, analyses, allWriteResults) {
+  let totalGroups = analyses.length, groupsWithAction = analyses.filter(
+    (a) => a.type !== "no-action-needed" && a.type !== "no-change-needed"
+  ).length, flatResults = allWriteResults.flat(), successfulWrites = flatResults.filter((r) => r.success), filesSaved = successfulWrites.length, filesCreated = successfulWrites.filter(
+    (r) => r.operation.operation === "create"
+  ).length, filesUpdated = successfulWrites.filter(
+    (r) => r.operation.operation === "update"
+  ).length, platformSpecificFiles = successfulWrites.filter(
+    (r) => r.operation.isPlatformSpecific
+  ).length, interactiveResolutions = analyses.filter(
+    (a) => a.recommendedStrategy === "interactive" && a.type === "needs-resolution"
+  ).length, errors = flatResults.filter((r) => !r.success).map((r) => ({
+    path: r.operation.registryPath,
+    error: r.error || new Error("Unknown write error")
+  }));
+  return {
+    packageName,
+    totalGroups,
+    groupsWithAction,
+    filesSaved,
+    filesCreated,
+    filesUpdated,
+    platformSpecificFiles,
+    interactiveResolutions,
+    errors,
+    writeResults: flatResults
+  };
+}
+function createCommandResult(report) {
+  return {
+    success: !0,
+    data: {
+      message: formatSaveMessage(report),
+      report
+    }
+  };
+}
+function createSuccessResult(packageName, message) {
+  return {
+    success: !0,
+    data: {
+      message,
+      packageName
+    }
+  };
+}
+function createErrorResult(error) {
+  return {
+    success: !1,
+    error
+  };
+}
+function formatSaveMessage(report) {
+  let lines = [];
+  if (report.filesSaved === 0 && report.errors.length === 0)
+    return `\u2713 Saved ${report.packageName}
+  No changes detected`;
+  lines.push(`\u2713 Saved ${report.packageName}`), report.filesCreated > 0 && lines.push(`  ${report.filesCreated} file(s) created`), report.filesUpdated > 0 && lines.push(`  ${report.filesUpdated} file(s) updated`), report.platformSpecificFiles > 0 && lines.push(`  ${report.platformSpecificFiles} platform-specific file(s)`), report.interactiveResolutions > 0 && lines.push(`  ${report.interactiveResolutions} interactive resolution(s)`), report.errors.length > 0 && (lines.push(""), lines.push(`\u26A0\uFE0F  ${report.errors.length} error(s) occurred:`), report.errors.forEach((err) => {
+    lines.push(`  \u2022 ${err.path}: ${err.error.message}`);
+  }));
+  let successfulWrites = report.writeResults.filter((r) => r.success);
+  if (successfulWrites.length > 0) {
+    lines.push(""), lines.push("  Files saved:");
+    let sorted = [...successfulWrites].sort(
+      (a, b) => a.operation.registryPath.localeCompare(b.operation.registryPath)
+    );
+    for (let result of sorted) {
+      let { registryPath, isPlatformSpecific, platform } = result.operation, label = isPlatformSpecific && platform ? `${registryPath} (${platform})` : `${registryPath} (universal)`;
+      lines.push(`   \u251C\u2500\u2500 ${label}`);
+    }
+  }
+  return report.filesSaved > 0 && (lines.push(""), lines.push("\u{1F4A1} Changes saved to package source."), lines.push("   To sync changes to workspace, run:"), lines.push(`     opkg install ${report.packageName}`)), lines.join(`
+`);
+}
+
+// ../core/src/core/save/save-to-source-pipeline.ts
+async function runSaveToSourcePipeline(packageName, options = {}, ctx) {
+  try {
+    await initSharedTempDir(), logger.debug(`Validating save preconditions for ${packageName}`);
+    let validation = await validateSavePreconditions(packageName);
+    if (!validation.valid)
+      return createErrorResult(validation.error);
+    let { cwd, packageRoot, filesMapping } = validation;
+    logger.debug(`Building candidates for ${packageName}`);
+    let candidateResult = await buildCandidates({
+      packageRoot,
+      workspaceRoot: cwd,
+      filesMapping
+    });
+    candidateResult.errors.length > 0 && (logger.warn(`Encountered ${candidateResult.errors.length} error(s) building candidates`), candidateResult.errors.forEach(
+      (err) => logger.warn(`  ${err.path}: ${err.reason}`)
+    )), logger.debug("Building candidate groups");
+    let allGroups = buildCandidateGroups(
+      candidateResult.localSourceRefs,
+      candidateResult.workspaceCandidates,
+      cwd
+    ), activeGroups = filterGroupsWithWorkspace(allGroups);
+    if (activeGroups.length === 0)
+      return logger.info(`No workspace changes detected for ${packageName}`), createSuccessResult(
+        packageName,
+        `\u2713 Saved ${packageName}
+  No workspace changes detected`
+      );
+    logger.debug("Pruning existing platform-specific files"), await pruneExistingPlatformCandidates(packageRoot, activeGroups);
+    let finalGroups = activeGroups.filter((g) => g.workspace.length > 0);
+    if (finalGroups.length === 0)
+      return logger.info(`No workspace changes detected for ${packageName}`), createSuccessResult(
+        packageName,
+        `\u2713 Saved ${packageName}
+  No workspace changes detected`
+      );
+    for (let group of finalGroups)
+      group.localRef && !group.local && (group.local = await materializeLocalCandidate(group.localRef, packageRoot) ?? void 0);
+    logger.debug(`Processing ${finalGroups.length} group(s) with workspace candidates`);
+    let groupAnalyses = await Promise.all(
+      finalGroups.map(async (group) => ({
+        group,
+        analysis: await analyzeGroup(group, options.force ?? !1, cwd)
+      }))
+    ), analyses = groupAnalyses.map((ga) => ga.analysis), allWriteResults = [], autoResolvable = [], interactive = [];
+    for (let ga of groupAnalyses) {
+      if (ga.analysis.type === "no-action-needed" || ga.analysis.type === "no-change-needed") {
+        logger.debug(`Skipping ${ga.group.registryPath}: ${ga.analysis.type}`);
+        continue;
+      }
+      ga.analysis.recommendedStrategy === "interactive" ? interactive.push(ga) : autoResolvable.push(ga);
+    }
+    if (autoResolvable.length > 0) {
+      logger.debug(`Processing ${autoResolvable.length} auto-resolvable group(s) in parallel`);
+      let autoResults = await Promise.all(
+        autoResolvable.map(async ({ group, analysis }) => {
+          let resolution = await executeResolution(group, analysis, packageRoot, cwd, resolveOutput(ctx), resolvePrompt(ctx));
+          return resolution ? writeResolution(packageRoot, group.registryPath, resolution, group.local, cwd) : null;
+        })
+      );
+      for (let result of autoResults)
+        result && allWriteResults.push(result);
+    }
+    for (let { group, analysis } of interactive) {
+      let resolution = await executeResolution(group, analysis, packageRoot, cwd, resolveOutput(ctx), resolvePrompt(ctx));
+      if (!resolution) {
+        logger.debug(`No resolution returned for ${group.registryPath}`);
+        continue;
+      }
+      let writeResults = await writeResolution(
+        packageRoot,
+        group.registryPath,
+        resolution,
+        group.local,
+        cwd
+      );
+      allWriteResults.push(writeResults);
+    }
+    logger.debug("Building save report");
+    let report = buildSaveReport(packageName, analyses, allWriteResults);
+    return createCommandResult(report);
+  } finally {
+    clearConversionCache(), await cleanupSharedTempDir();
+  }
+}
+async function validateSavePreconditions(packageName) {
+  let cwd = process.cwd();
+  if (!packageName)
+    return {
+      valid: !1,
+      error: "Package name is required for save."
+    };
+  let index;
+  try {
+    index = (await readWorkspaceIndex(cwd)).index;
+  } catch (error) {
+    return {
+      valid: !1,
+      error: `Failed to read workspace index: ${error}`
+    };
+  }
+  let pkgIndex = index.packages?.[packageName];
+  if (!pkgIndex)
+    return {
+      valid: !1,
+      error: `Package '${packageName}' is not installed in this workspace.
+Run 'opkg install ${packageName}' to install it first.`
+    };
+  if (!pkgIndex.files || Object.keys(pkgIndex.files).length === 0)
+    return {
+      valid: !1,
+      error: `Package '${packageName}' has no files installed.
+Nothing to save.`
+    };
+  let source;
+  try {
+    source = await resolvePackageSource(cwd, packageName);
+  } catch (error) {
+    return {
+      valid: !1,
+      error: `Failed to resolve package source: ${error}`
+    };
+  }
+  try {
+    assertMutableSourceOrThrow(source.absolutePath, {
+      packageName: source.packageName,
+      command: "save"
+    });
+  } catch (error) {
+    return {
+      valid: !1,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+  return {
+    valid: !0,
+    cwd,
+    packageRoot: source.absolutePath,
+    filesMapping: pkgIndex.files
+  };
+}
+
+// src/commands/save.ts
+async function setupSaveCommand(args) {
+  let [packageName, options] = args, ctx = await createCliExecutionContext(), out = resolveOutput(ctx), result = await runSaveToSourcePipeline(packageName, options, ctx);
+  if (!result.success)
+    throw new Error(result.error || "Save operation failed");
+  result.data?.message && out.success(result.data.message);
+}
+export {
+  setupSaveCommand
+};
+//# sourceMappingURL=save-24TESYKI.js.map