opkg 0.9.0 → 0.9.2

package/packages/cli/dist/chunk-ELCB4RC2.js

@@ -0,0 +1,1121 @@
+#!/usr/bin/env node
+import {
+  applyMapPipeline,
+  createMapContext,
+  defaultTransformRegistry,
+  parseMarkdownDocument,
+  serializeMarkdownDocument,
+  splitMapPipeline,
+  validateMapPipeline
+} from "./chunk-IXOEIRDT.js";
+import {
+  CLOSE_MARKER,
+  CLOSE_MARKER_REGEX,
+  buildOpenMarker,
+  buildOpenMarkerRegex,
+  extractAllKeys
+} from "./chunk-QURLGVA4.js";
+import {
+  stripPlatformSuffixFromFilename
+} from "./chunk-UDAWJRKD.js";
+import {
+  composeMarkdown,
+  deepEqualYaml,
+  deepMerge,
+  extractInlinePlatformOverrides,
+  splitFrontmatter
+} from "./chunk-KGBDKY5V.js";
+import {
+  resolveSwitchExpression,
+  smartEquals,
+  smartNotEquals,
+  validateSwitchExpression
+} from "./chunk-GKEHDSL4.js";
+import {
+  FILE_PATTERNS
+} from "./chunk-J4IFFBLP.js";
+import {
+  ensureDir,
+  exists,
+  readTextFile,
+  writeTextFile
+} from "./chunk-S47F4OG4.js";
+import {
+  logger
+} from "./chunk-5EFWGD33.js";
+
+// ../core/src/utils/hash-utils.ts
+import { xxhash3 } from "hash-wasm";
+async function calculateFileHash(content) {
+  try {
+    return await xxhash3(content);
+  } catch (error) {
+    return logger.warn(`Failed to calculate hash for content: ${error}`), `${content.length}-${content.charAt(0)}-${content.charAt(content.length - 1)}`;
+  }
+}
+
+// ../core/src/core/flows/flow-executor.ts
+import { promises as fs2 } from "fs";
+import fsSync from "fs";
+import path2 from "path";
+import yaml from "js-yaml";
+import * as TOML from "smol-toml";
+import { parse as parseJsonc } from "jsonc-parser";
+import { JSONPath } from "jsonpath-plus";
+
+// ../core/src/utils/root-file-merger.ts
+function mergePackageContentIntoRootFile(existingContent, packageName, newContent) {
+  if (!packageName)
+    throw new Error("Package name is required for merging");
+  let openMarker = buildOpenMarker(packageName), closeMarker = CLOSE_MARKER, openRe = buildOpenMarkerRegex(packageName), closeRe = CLOSE_MARKER_REGEX, openMatch = openRe.exec(existingContent);
+  if (!openMatch) {
+    let separator = existingContent.trim() ? `
+
+` : "";
+    return existingContent.trim() + separator + openMarker + `
+` + newContent.trim() + `
+` + closeMarker + `
+`;
+  }
+  let beforeSection = existingContent.substring(0, openMatch.index), afterMarkerIndex = openMatch.index + openMatch[0].length, restContent = existingContent.substring(afterMarkerIndex), closeMatch = closeRe.exec(restContent);
+  if (!closeMatch) {
+    let separator = existingContent.trim() ? `
+
+` : "";
+    return existingContent.trim() + separator + openMarker + `
+` + newContent.trim() + `
+` + closeMarker + `
+`;
+  }
+  let existingSectionBody = restContent.substring(0, closeMatch.index).trim(), afterCloseMarkerIndex = closeMatch.index + closeMatch[0].length, afterSection = restContent.substring(afterCloseMarkerIndex), hasCorrectMarker = openMatch[0] === openMarker, hasCorrectContent = existingSectionBody === newContent.trim();
+  return hasCorrectMarker && hasCorrectContent && !0 ? existingContent : beforeSection + openMarker + `
+` + newContent.trim() + `
+` + closeMarker + afterSection;
+}
+
+// ../core/src/core/glob-target-mapping.ts
+import { extname } from "path";
+function normalizeSlashPath(input) {
+  return input.replace(/\\/g, "/");
+}
+function splitSegments(input) {
+  return normalizeSlashPath(input).split("/").filter(Boolean);
+}
+function stripOverlappingDestBaseFromSource(destBase, sourceRelFromPackage) {
+  let destSegments = splitSegments(destBase), sourceSegments = splitSegments(sourceRelFromPackage), maxOverlap = Math.min(destSegments.length, sourceSegments.length), overlapLen = 0;
+  for (let k = maxOverlap; k >= 1; k--) {
+    let destSuffix = destSegments.slice(-k).join("/"), sourcePrefix = sourceSegments.slice(0, k).join("/");
+    if (destSuffix === sourcePrefix) {
+      overlapLen = k;
+      break;
+    }
+  }
+  return sourceSegments.slice(overlapLen).join("/");
+}
+function extractTargetExtensionFromRecursiveSuffix(toSuffix) {
+  return normalizeSlashPath(toSuffix).match(/(\.[^/]+)$/)?.[1] ?? null;
+}
+function resolveRecursiveGlobTargetRelativePath(sourceRelFromPackage, fromPattern, toPattern) {
+  let toParts = normalizeSlashPath(toPattern).split("**"), toBase = toParts[0].replace(/\/$/, ""), toSuffix = toParts[1] || "", relativeSubpath = sourceRelFromPackage;
+  if (fromPattern.includes("**")) {
+    let fromParts = normalizeSlashPath(fromPattern).split("**"), fromBase = fromParts[0].replace(/\/$/, ""), fromSuffix = fromParts[1] || "";
+    if (fromBase) {
+      let normalizedSource = normalizeSlashPath(sourceRelFromPackage);
+      relativeSubpath = normalizedSource.startsWith(fromBase + "/") ? normalizedSource.slice(fromBase.length + 1) : normalizedSource;
+    }
+    if (fromSuffix && toSuffix) {
+      let fromExt = fromSuffix.replace(/^\/?\*+/, ""), toExt = toSuffix.replace(/^\/?\*+/, "");
+      fromExt && toExt && fromExt !== toExt && (relativeSubpath = relativeSubpath.replace(
+        new RegExp(fromExt.replace(".", "\\.") + "$"),
+        toExt
+      ));
+    }
+  } else {
+    relativeSubpath = toBase ? stripOverlappingDestBaseFromSource(toBase, sourceRelFromPackage) : normalizeSlashPath(sourceRelFromPackage);
+    let toExt = extractTargetExtensionFromRecursiveSuffix(toSuffix);
+    if (toExt && toExt.startsWith(".")) {
+      let currentExt = extname(relativeSubpath);
+      currentExt && currentExt !== toExt && (relativeSubpath = relativeSubpath.slice(0, -currentExt.length) + toExt);
+    }
+  }
+  return relativeSubpath = stripPlatformSuffixFromFilename(relativeSubpath), normalizeSlashPath(toBase ? `${toBase}/${relativeSubpath}` : relativeSubpath);
+}
+
+// ../core/src/core/platform-yaml-merge.ts
+function mergeInlinePlatformOverride(universalContent, targetPlatform, cwd) {
+  try {
+    let trimmed = universalContent.trim();
+    if (!trimmed.endsWith(FILE_PATTERNS.MD_FILES) && !trimmed.startsWith("---"))
+      return universalContent;
+    let { frontmatter, body, rawFrontmatter } = splitFrontmatter(universalContent), { common, overridesByPlatform } = extractInlinePlatformOverrides(frontmatter, cwd), override = overridesByPlatform.get(targetPlatform) ?? {}, mergedData = deepMerge(common, override);
+    return rawFrontmatter !== void 0 && deepEqualYaml(frontmatter, mergedData) || rawFrontmatter === void 0 && Object.keys(mergedData).length === 0 ? universalContent : composeMarkdown(mergedData, body);
+  } catch {
+    return universalContent;
+  }
+}
+
+// ../core/src/core/flows/flow-key-mapper.ts
+function getNestedValue(obj, path3) {
+  if (!path3)
+    return obj;
+  let keys = path3.split("."), current = obj;
+  for (let key of keys)
+    if (current && typeof current == "object" && key in current)
+      current = current[key];
+    else
+      return;
+  return current;
+}
+function setNestedValue(obj, path3, value) {
+  if (!path3)
+    return;
+  let keys = path3.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 finalKey = keys[keys.length - 1];
+  current[finalKey] = value;
+}
+function deleteNestedValue(obj, path3) {
+  if (!path3)
+    return;
+  let keys = path3.split("."), current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    let key = keys[i];
+    if (!(key in current) || typeof current[key] != "object")
+      return;
+    current = current[key];
+  }
+  let finalKey = keys[keys.length - 1];
+  delete current[finalKey];
+}
+
+// ../core/src/core/flows/source-resolver.ts
+import { promises as fs } from "fs";
+import path from "path";
+import { minimatch } from "minimatch";
+var SourcePatternResolver = class {
+  /**
+   * Resolve source pattern(s) to file paths
+   * 
+   * For single patterns: returns all matching files
+   * For array patterns: returns files from first matching pattern only (priority order)
+   * 
+   * @param pattern - Single pattern or array of patterns with priority
+   * @param options - Resolution options
+   * @returns Resolution result with paths and warnings
+   */
+  async resolve(pattern, options) {
+    return Array.isArray(pattern) ? this.resolveWithPriority(pattern, options) : {
+      paths: await this.resolveSinglePattern(pattern, options.baseDir),
+      warnings: []
+    };
+  }
+  /**
+   * Resolve array of patterns with priority (first match wins)
+   * 
+   * Iterates through patterns in order, returning files from first matching pattern.
+   * Logs warnings if lower-priority patterns also match.
+   * 
+   * @param patterns - Array of patterns in priority order
+   * @param options - Resolution options
+   * @returns Resolution result
+   */
+  async resolveWithPriority(patterns, options) {
+    if (patterns.length === 0)
+      return { paths: [], warnings: ["Empty pattern array provided"] };
+    let warnings = [], skippedPatterns = [];
+    for (let i = 0; i < patterns.length; i++) {
+      let currentPattern = patterns[i], matches = await this.resolveSinglePattern(currentPattern, options.baseDir);
+      if (matches.length > 0) {
+        for (let j = i + 1; j < patterns.length; j++) {
+          let lowerPriorityPattern = patterns[j], lowerMatches = await this.resolveSinglePattern(
+            lowerPriorityPattern,
+            options.baseDir
+          );
+          if (lowerMatches.length > 0) {
+            let warning = `Pattern "${currentPattern}" matched (priority ${i + 1}). Ignoring lower-priority pattern "${lowerPriorityPattern}" (priority ${j + 1}) which also matched ${lowerMatches.length} file(s).`;
+            warnings.push(warning), skippedPatterns.push(lowerPriorityPattern), options.logWarnings !== !1 && logger.debug(warning);
+          }
+        }
+        return {
+          paths: matches,
+          warnings,
+          matchedPattern: currentPattern,
+          skippedPatterns: skippedPatterns.length > 0 ? skippedPatterns : void 0
+        };
+      }
+    }
+    return {
+      paths: [],
+      warnings: [`No files matched any of the ${patterns.length} pattern(s): ${patterns.join(", ")}`]
+    };
+  }
+  /**
+   * Resolve a single pattern to file paths
+   * 
+   * Handles both glob patterns and literal file paths.
+   * 
+   * @param pattern - File pattern (may contain globs)
+   * @param baseDir - Base directory for resolution
+   * @returns Array of resolved file paths
+   */
+  async resolveSinglePattern(pattern, baseDir) {
+    if (this.isGlobPattern(pattern))
+      return this.resolveGlobPattern(pattern, baseDir);
+    let resolved = path.join(baseDir, pattern);
+    return await exists(resolved) ? [resolved] : [];
+  }
+  /**
+   * Check if pattern contains glob wildcards
+   * 
+   * @param pattern - Pattern to check
+   * @returns True if pattern contains glob syntax
+   */
+  isGlobPattern(pattern) {
+    return pattern.includes("*") || pattern.includes("?") || pattern.includes("[");
+  }
+  /**
+   * Resolve glob pattern to matching files
+   * 
+   * @param pattern - Glob pattern
+   * @param baseDir - Base directory
+   * @returns Array of matching file paths
+   */
+  async resolveGlobPattern(pattern, baseDir) {
+    let matches = [], parts = pattern.split("/"), globPart = parts.findIndex((p) => this.isGlobPattern(p));
+    if (globPart === -1)
+      return [path.join(baseDir, pattern)];
+    let dirPath = path.join(baseDir, ...parts.slice(0, globPart)), filePattern = parts.slice(globPart).join("/");
+    return await exists(dirPath) ? (await this.findMatchingFiles(dirPath, filePattern, baseDir, matches), matches) : [];
+  }
+  /**
+   * Recursively find files matching glob pattern
+   * 
+   * Supports ** for recursive directory matching.
+   * 
+   * @param dir - Current directory
+   * @param pattern - Pattern to match
+   * @param baseDir - Base directory for relative paths
+   * @param matches - Array to accumulate matches
+   */
+  async findMatchingFiles(dir, pattern, baseDir, matches) {
+    try {
+      let entries = await fs.readdir(dir, { withFileTypes: !0 });
+      for (let entry of entries) {
+        let fullPath = path.join(dir, entry.name), relativePath = path.relative(baseDir, fullPath);
+        entry.isDirectory() ? pattern.startsWith("**") || pattern.includes("/**/") ? await this.findMatchingFiles(fullPath, pattern, baseDir, matches) : pattern.includes("/") && await this.findMatchingFiles(fullPath, pattern, baseDir, matches) : entry.isFile() && minimatch(relativePath, pattern, { dot: !1 }) && matches.push(fullPath);
+      }
+    } catch (error) {
+      logger.debug(`Error reading directory ${dir}: ${error}`);
+    }
+  }
+};
+
+// ../core/src/core/flows/flow-executor.ts
+var DefaultFlowExecutor = class {
+  constructor(transformRegistry) {
+    this.transformRegistry = transformRegistry || defaultTransformRegistry, this.sourceResolver = new SourcePatternResolver();
+  }
+  /**
+   * Execute a single flow (now supports glob patterns and switch expressions)
+   */
+  async executeFlow(flow, context) {
+    let startTime = Date.now();
+    try {
+      let resolvedFrom = flow.from;
+      if (this.isSwitchExpression(flow.from))
+        try {
+          resolvedFrom = resolveSwitchExpression(flow.from, context);
+        } catch (error) {
+          return {
+            source: "<switch expression>",
+            target: this.normalizeToPattern(flow.to),
+            success: !1,
+            transformed: !1,
+            error: error instanceof Error ? error : new Error(String(error)),
+            executionTime: Date.now() - startTime
+          };
+        }
+      let resolvedTo = flow.to;
+      if (this.isSwitchExpression(flow.to))
+        try {
+          resolvedTo = resolveSwitchExpression(flow.to, context);
+        } catch (error) {
+          return {
+            source: this.normalizeFromPattern(resolvedFrom),
+            target: "<switch expression>",
+            success: !1,
+            transformed: !1,
+            error: error instanceof Error ? error : new Error(String(error)),
+            executionTime: Date.now() - startTime
+          };
+        }
+      if (typeof resolvedTo != "string") {
+        let results2 = await this.executeMultiTarget({ ...flow, from: resolvedFrom, to: resolvedTo }, context);
+        return this.aggregateResults(results2, startTime);
+      }
+      let validation = this.validateFlow({ ...flow, from: resolvedFrom, to: resolvedTo });
+      if (!validation.valid)
+        return {
+          source: this.normalizeFromPattern(resolvedFrom),
+          target: resolvedTo,
+          success: !1,
+          transformed: !1,
+          error: new Error(`Invalid flow: ${validation.errors.map((e) => e.message).join(", ")}`),
+          executionTime: Date.now() - startTime
+        };
+      if (flow.when && !this.evaluateCondition(flow.when, context)) {
+        let normalized = this.normalizeFromPattern(resolvedFrom);
+        return logger.debug(`Flow skipped due to condition: ${normalized} -> ${resolvedTo}`), {
+          source: normalized,
+          target: resolvedTo,
+          success: !0,
+          transformed: !1,
+          warnings: ["Flow skipped due to condition"],
+          executionTime: Date.now() - startTime
+        };
+      }
+      let resolution = await this.resolveSourcePattern(resolvedFrom, context), sourcePaths = resolution.paths, resolutionWarnings = resolution.warnings;
+      if (sourcePaths.length === 0)
+        return {
+          source: this.normalizeFromPattern(resolvedFrom),
+          target: resolvedTo,
+          success: !0,
+          transformed: !1,
+          warnings: resolutionWarnings.length > 0 ? resolutionWarnings : ["No files matched pattern"],
+          executionTime: Date.now() - startTime
+        };
+      let results = [], firstFromPattern = this.getFirstPattern(resolvedFrom);
+      for (let sourcePath of sourcePaths) {
+        let targetPath = this.resolveTargetFromGlob(sourcePath, firstFromPattern, resolvedTo, context), result = await this.executePipeline(flow, sourcePath, targetPath, context);
+        results.push({
+          ...result,
+          executionTime: Date.now() - startTime
+        });
+      }
+      return resolutionWarnings.length > 0 && results.length > 0 && (results[0].warnings = [
+        ...results[0].warnings || [],
+        ...resolutionWarnings
+      ]), results.length === 1 ? results[0] : this.aggregateResults(results, startTime);
+    } catch (error) {
+      return {
+        source: this.isSwitchExpression(flow.from) ? "<switch>" : this.normalizeFromPattern(flow.from),
+        target: this.normalizeToPattern(flow.to),
+        success: !1,
+        transformed: !1,
+        error: error instanceof Error ? error : new Error(String(error)),
+        executionTime: Date.now() - startTime
+      };
+    }
+  }
+  /**
+   * Execute multiple flows
+   */
+  async executeFlows(flows, context) {
+    let results = [];
+    for (let flow of flows) {
+      let result = await this.executeFlow(flow, context);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Execute a multi-target flow
+   */
+  async executeMultiTarget(flow, context) {
+    if (typeof flow.to == "string")
+      throw new Error("Flow is not a multi-target flow");
+    let multiTarget = flow.to, normalizedFrom = this.normalizeFromPattern(flow.from), resolution = await this.resolveSourcePattern(flow.from, context), sourcePaths = resolution.paths;
+    if (sourcePaths.length === 0)
+      return Object.keys(multiTarget).map((target) => ({
+        source: normalizedFrom,
+        target,
+        success: !0,
+        transformed: !1,
+        warnings: resolution.warnings.length > 0 ? resolution.warnings : ["No files matched pattern"]
+      }));
+    let allResults = [], firstFromPattern = this.getFirstPattern(flow.from);
+    for (let sourcePath of sourcePaths) {
+      let sourceContent = await this.loadSourceFile(sourcePath, context);
+      for (let [targetPath, targetFlow] of Object.entries(multiTarget)) {
+        let startTime = Date.now();
+        try {
+          let mergedFlow = {
+            ...flow,
+            ...targetFlow,
+            from: flow.from,
+            to: targetPath
+          };
+          if (mergedFlow.when && !this.evaluateCondition(mergedFlow.when, context)) {
+            logger.debug(`Multi-target flow skipped due to condition: ${normalizedFrom} -> ${targetPath}`), allResults.push({
+              source: normalizedFrom,
+              target: targetPath,
+              success: !0,
+              transformed: !1,
+              warnings: ["Flow skipped due to condition"],
+              executionTime: Date.now() - startTime
+            });
+            continue;
+          }
+          let resolvedTargetPath = this.resolveTargetFromGlob(sourcePath, firstFromPattern, targetPath, context), result = await this.executePipelineWithContent(
+            mergedFlow,
+            sourceContent,
+            sourcePath,
+            resolvedTargetPath,
+            context
+          );
+          allResults.push({
+            ...result,
+            executionTime: Date.now() - startTime
+          });
+        } catch (error) {
+          allResults.push({
+            source: normalizedFrom,
+            target: targetPath,
+            success: !1,
+            transformed: !1,
+            error: error instanceof Error ? error : new Error(String(error)),
+            executionTime: Date.now() - startTime
+          });
+        }
+      }
+    }
+    return allResults;
+  }
+  /**
+   * Validate a flow configuration
+   */
+  validateFlow(flow) {
+    let errors = [];
+    if (flow.from || errors.push({ message: 'Flow missing required field "from"', code: "MISSING_FROM" }), flow.to || errors.push({ message: 'Flow missing required field "to"', code: "MISSING_TO" }), flow.to && this.isSwitchExpression(flow.to)) {
+      let switchValidation = validateSwitchExpression(flow.to);
+      if (!switchValidation.valid)
+        for (let error of switchValidation.errors)
+          errors.push({
+            message: error,
+            code: "INVALID_SWITCH_EXPRESSION"
+          });
+    }
+    if (flow.pick && flow.omit && errors.push({ message: 'Flow cannot have both "pick" and "omit"', code: "CONFLICTING_FILTERS" }), flow.merge && !["deep", "shallow", "replace", "composite"].includes(flow.merge) && errors.push({
+      message: `Invalid merge strategy: ${flow.merge}. Must be one of: deep, shallow, replace, composite`,
+      code: "INVALID_MERGE"
+    }), flow.path)
+      try {
+        JSONPath({ path: flow.path, json: {} });
+      } catch {
+        errors.push({
+          message: `Invalid JSONPath expression: ${flow.path}`,
+          code: "INVALID_JSONPATH"
+        });
+      }
+    if (flow.map) {
+      let mapPipelineValidation = validateMapPipeline(flow.map);
+      if (!mapPipelineValidation.valid)
+        for (let error of mapPipelineValidation.errors)
+          errors.push({
+            message: error,
+            code: "INVALID_MAP_PIPELINE"
+          });
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings: []
+    };
+  }
+  /**
+   * Check if a value is a switch expression
+   */
+  isSwitchExpression(value) {
+    return typeof value == "object" && value !== null && "$switch" in value;
+  }
+  /**
+   * Execute the transformation pipeline
+   */
+  async executePipeline(flow, sourcePath, targetPath, context) {
+    if (!this.needsParsing(flow, sourcePath, targetPath, context))
+      return await this.executePassThroughCopy(flow, sourcePath, targetPath, context);
+    let sourceContent = await this.loadSourceFile(sourcePath, context);
+    return this.executePipelineWithContent(flow, sourceContent, sourcePath, targetPath, context);
+  }
+  /**
+   * Execute pipeline with pre-loaded content (for multi-target flows)
+   */
+  async executePipelineWithContent(flow, sourceContent, sourcePath, targetPath, context) {
+    let warnings = [], conflicts = [], data = sourceContent.data, transformed = !1;
+    try {
+      flow.path && (data = this.extractJSONPath(data, flow.path), transformed = !0), flow.pick ? (data = this.pickKeys(data, flow.pick), transformed = !0) : flow.omit && (data = this.omitKeys(data, flow.omit), transformed = !0);
+      let contributedKeys, schemaOps = [], pipeOps = [];
+      if (flow.map) {
+        let split = splitMapPipeline(flow.map);
+        if (schemaOps = split.schemaOps, pipeOps = split.pipeOps, schemaOps.length > 0) {
+          let mapContext = createMapContext({
+            filename: path2.basename(sourcePath, path2.extname(sourcePath)),
+            dirname: path2.basename(path2.dirname(sourcePath)),
+            path: path2.relative(context.packageRoot, sourcePath),
+            ext: path2.extname(sourcePath)
+          });
+          data && typeof data == "object" && "frontmatter" in data ? data.frontmatter = applyMapPipeline(
+            data.frontmatter,
+            schemaOps,
+            mapContext,
+            this.transformRegistry
+          ) : data = applyMapPipeline(
+            data,
+            schemaOps,
+            mapContext,
+            this.transformRegistry
+          ), transformed = !0;
+        }
+      }
+      if (!!flow.merge && flow.merge !== "replace" && flow.merge !== "composite" && typeof data == "object" && data !== null) {
+        let dataToExtract = data && "frontmatter" in data ? data.frontmatter : data;
+        typeof dataToExtract == "object" && dataToExtract !== null && (contributedKeys = extractAllKeys(dataToExtract));
+      }
+      let targetExists = await exists(targetPath);
+      if (flow.embed && (data = this.embedContent(data, flow.embed), transformed = !0), targetExists) {
+        let targetContent = await this.loadSourceFile(targetPath, context);
+        if (flow.merge === "composite") {
+          let sourceRaw = sourceContent.raw, targetRaw = targetContent.raw;
+          data = mergePackageContentIntoRootFile(targetRaw, context.packageName, sourceRaw), transformed = !0;
+        } else {
+          let mergeResult = this.mergeContent(
+            data,
+            targetContent.data,
+            flow.merge || "replace",
+            context
+          );
+          data = mergeResult.data, conflicts.push(...mergeResult.conflicts), mergeResult.conflicts.length > 0 && (transformed = !0);
+        }
+      }
+      if (pipeOps.length > 0) {
+        let mapContext = createMapContext({
+          filename: path2.basename(sourcePath, path2.extname(sourcePath)),
+          dirname: path2.basename(path2.dirname(sourcePath)),
+          path: path2.relative(context.packageRoot, sourcePath),
+          ext: path2.extname(sourcePath)
+        });
+        data && typeof data == "object" && "frontmatter" in data ? data.frontmatter = applyMapPipeline(
+          data.frontmatter,
+          pipeOps,
+          mapContext,
+          this.transformRegistry
+        ) : data = applyMapPipeline(
+          data,
+          pipeOps,
+          mapContext,
+          this.transformRegistry
+        ), transformed = !0;
+      }
+      return context.dryRun || await this.writeTargetFile(targetPath, data, sourceContent.format), {
+        source: sourcePath,
+        target: targetPath,
+        success: !0,
+        transformed,
+        keys: contributedKeys,
+        merge: flow.merge,
+        warnings: warnings.length > 0 ? warnings : void 0,
+        conflicts: conflicts.length > 0 ? conflicts : void 0,
+        pipeline: this.getPipeline(flow)
+      };
+    } catch (error) {
+      return {
+        source: sourcePath,
+        target: targetPath,
+        success: !1,
+        transformed,
+        error: error instanceof Error ? error : new Error(String(error)),
+        warnings: warnings.length > 0 ? warnings : void 0
+      };
+    }
+  }
+  /**
+   * Load and parse source file
+   */
+  async loadSourceFile(filePath, context) {
+    let raw = await readTextFile(filePath), format = this.detectFormat(filePath, raw);
+    return (format === "markdown" || format === "md") && context?.platform && context?.direction === "install" && (raw = mergeInlinePlatformOverride(raw, context.platform, context.workspaceRoot)), { data: this.parseSourceContent(raw, format), format, raw };
+  }
+  /**
+   * Write transformed content to target file
+   */
+  async writeTargetFile(filePath, content, sourceFormat) {
+    await ensureDir(path2.dirname(filePath));
+    let targetFormat = this.detectFormat(filePath, ""), serialized = this.serializeTargetContent(content, targetFormat);
+    await writeTextFile(filePath, serialized);
+  }
+  /**
+   * Determine if parsing is needed for this flow
+   * Returns false for simple pass-through copies with no transformations
+   */
+  needsParsing(flow, sourcePath, targetPath, context) {
+    if (flow.map || flow.pick || flow.omit || flow.path || flow.embed || flow.merge && (flow.merge === "deep" || flow.merge === "shallow"))
+      return !0;
+    let sourceExt = path2.extname(sourcePath).toLowerCase(), targetExt = path2.extname(targetPath).toLowerCase();
+    return !!(sourceExt !== targetExt && [".json", ".jsonc", ".yaml", ".yml", ".toml"].includes(sourceExt) || (sourceExt === ".md" || sourceExt === ".mdc" || sourceExt === ".markdown") && context.platform && context.direction === "install");
+  }
+  /**
+   * Execute a pass-through copy without parsing
+   * Used for simple file copies with no transformations
+   */
+  async executePassThroughCopy(flow, sourcePath, targetPath, context) {
+    let warnings = [];
+    try {
+      if (await exists(targetPath) && flow.merge && flow.merge !== "replace") {
+        logger.warn(`Pass-through copy attempted with merge strategy '${flow.merge}' - falling back to parsed pipeline`);
+        let sourceContent = await this.loadSourceFile(sourcePath, context);
+        return this.executePipelineWithContent(flow, sourceContent, sourcePath, targetPath, context);
+      }
+      if (!context.dryRun) {
+        await ensureDir(path2.dirname(targetPath));
+        let content = await fs2.readFile(sourcePath);
+        await fs2.writeFile(targetPath, content);
+      }
+      return {
+        source: sourcePath,
+        target: targetPath,
+        success: !0,
+        transformed: !1,
+        warnings: warnings.length > 0 ? warnings : void 0
+      };
+    } catch (error) {
+      return {
+        source: sourcePath,
+        target: targetPath,
+        success: !1,
+        transformed: !1,
+        error: error instanceof Error ? error : new Error(String(error)),
+        warnings: warnings.length > 0 ? warnings : void 0
+      };
+    }
+  }
+  /**
+   * Parse source content based on format
+   */
+  parseSourceContent(content, format) {
+    if (!content.trim())
+      switch (format) {
+        case "json":
+        case "jsonc":
+        case "yaml":
+        case "yml":
+        case "toml":
+          return {};
+        case "markdown":
+        case "md":
+          return { body: "" };
+        case "text":
+        case "txt":
+        default:
+          return content;
+      }
+    try {
+      switch (format) {
+        case "json":
+        case "jsonc":
+          let cleaned = content;
+          if (format === "jsonc") {
+            let parsed = parseJsonc(cleaned);
+            if (parsed === void 0)
+              throw new Error("jsonc-parser returned undefined");
+            return parsed;
+          }
+          return JSON.parse(cleaned);
+        case "yaml":
+        case "yml":
+          return yaml.load(content);
+        case "toml":
+          try {
+            return TOML.parse(content);
+          } catch (error) {
+            throw new Error(`TOML parse error: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        case "markdown":
+        case "md":
+          return this.parseMarkdown(content);
+        case "text":
+        case "txt":
+        default:
+          return content;
+      }
+    } catch (error) {
+      throw new Error(`Failed to parse ${format} content: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+   * Serialize content to target format
+   */
+  serializeTargetContent(content, format) {
+    try {
+      switch (format) {
+        case "json":
+        case "jsonc":
+          return JSON.stringify(content, null, 2);
+        case "yaml":
+        case "yml":
+          return yaml.dump(content, { indent: 2, flowLevel: -1, lineWidth: -1 });
+        case "toml":
+          if (typeof content == "string")
+            return content;
+          try {
+            let toml = TOML.stringify(content);
+            return content && typeof content == "object" && content.mcp_servers && (toml = this.applyCodexTomlFormatting(toml)), toml;
+          } catch (error) {
+            throw new Error(`TOML stringify error: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        case "markdown":
+        case "md":
+          return this.serializeMarkdown(content);
+        case "text":
+        case "txt":
+        default:
+          return typeof content == "string" ? content : JSON.stringify(content, null, 2);
+      }
+    } catch (error) {
+      throw new Error(`Failed to serialize ${format} content: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+   * Detect format from file extension or content
+   */
+  detectFormat(filePath, content) {
+    let ext = path2.extname(filePath).toLowerCase(), extMap = {
+      ".json": "json",
+      ".jsonc": "jsonc",
+      ".yaml": "yaml",
+      ".yml": "yml",
+      ".toml": "toml",
+      ".md": "markdown",
+      ".mdc": "markdown",
+      ".markdown": "markdown",
+      ".txt": "text"
+    };
+    return extMap[ext] ? extMap[ext] : content.trim().startsWith("{") || content.trim().startsWith("[") ? content.includes("//") || content.includes("/*") ? "jsonc" : "json" : content.includes(`---
+`) || content.includes(`
+---
+`) ? "markdown" : "text";
+  }
+  /**
+   * Extract data using JSONPath
+   */
+  extractJSONPath(data, jsonPath) {
+    try {
+      let result = JSONPath({ path: jsonPath, json: data });
+      return result.length === 1 ? result[0] : result;
+    } catch (error) {
+      throw new Error(`JSONPath extraction failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+   * Pick specified keys
+   */
+  pickKeys(data, keys) {
+    if (typeof data != "object" || data === null)
+      return data;
+    let result = Array.isArray(data) ? [] : {};
+    for (let key of keys)
+      key.includes(".") ? this.setNestedValue(result, key, this.getNestedValue(data, key)) : key in data && (result[key] = data[key]);
+    return result;
+  }
+  /**
+   * Omit specified keys
+   */
+  omitKeys(data, keys) {
+    if (typeof data != "object" || data === null)
+      return data;
+    let result = Array.isArray(data) ? [...data] : { ...data };
+    for (let key of keys)
+      key.includes(".") ? this.deleteNestedValue(result, key) : delete result[key];
+    return result;
+  }
+  /**
+   * Apply pipe transforms
+   */
+  async applyPipeTransforms(data, transforms, context) {
+    let result = data;
+    for (let transformSpec of transforms)
+      try {
+        let { name, options } = this.parseTransformSpec(transformSpec);
+        logger.debug(`Applying transform: ${name}`, options), result = this.transformRegistry.execute(name, result, options);
+      } catch (error) {
+        throw new Error(`Transform '${transformSpec}' failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    return result;
+  }
+  /**
+   * Parse transform specification
+   * Examples: "trim", "number", "pick-keys(keys=[a,b,c])"
+   */
+  parseTransformSpec(spec) {
+    let match = spec.match(/^([a-z-]+)(?:\((.+)\))?$/);
+    if (!match)
+      throw new Error(`Invalid transform specification: ${spec}`);
+    let [, name, optionsStr] = match;
+    if (!optionsStr)
+      return { name };
+    let options = {}, pairs = optionsStr.split(",").map((s) => s.trim());
+    for (let pair of pairs) {
+      let [key, value] = pair.split("=").map((s) => s.trim());
+      value.startsWith("[") && value.endsWith("]") ? options[key] = value.slice(1, -1).split(",").map((s) => s.trim()) : value === "true" || value === "false" ? options[key] = value === "true" : isNaN(Number(value)) ? options[key] = value : options[key] = Number(value);
+    }
+    return { name, options };
+  }
+  /**
+   * Embed content under a key
+   */
+  embedContent(data, key) {
+    return { [key]: data };
+  }
+  /**
+   * Merge content with priority-based conflict resolution
+   */
+  mergeContent(source, target, strategy, context) {
+    let conflicts = [], merged;
+    switch (strategy) {
+      case "replace":
+        merged = source;
+        break;
+      case "shallow":
+        merged = { ...target, ...source };
+        break;
+      case "deep":
+        merged = this.deepMerge(target, source, conflicts, context);
+        break;
+      case "composite":
+        merged = source;
+        break;
+      default:
+        merged = source;
+    }
+    return { data: merged, conflicts };
+  }
+  /**
+   * Deep merge two objects
+   */
+  deepMerge(target, source, conflicts, context, keyPath = "") {
+    if (typeof source != "object" || source === null || typeof target != "object" || target === null)
+      return source;
+    if (Array.isArray(source) && Array.isArray(target))
+      return [...target, ...source];
+    let result = { ...target };
+    for (let key of Object.keys(source)) {
+      let currentPath = keyPath ? `${keyPath}.${key}` : key;
+      key in target ? typeof source[key] == "object" && typeof target[key] == "object" ? result[key] = this.deepMerge(target[key], source[key], conflicts, context, currentPath) : source[key] !== target[key] && (conflicts.push({
+        path: currentPath,
+        winner: context.packageName,
+        losers: ["existing"],
+        type: "value",
+        resolution: "last-writer-wins"
+      }), result[key] = source[key]) : result[key] = source[key];
+    }
+    return result;
+  }
+  /**
+   * Evaluate condition
+   */
+  evaluateCondition(condition, context) {
+    if (condition.and)
+      return condition.and.every((c) => this.evaluateCondition(c, context));
+    if (condition.or)
+      return condition.or.some((c) => this.evaluateCondition(c, context));
+    if (condition.not)
+      return !this.evaluateCondition(condition.not, context);
+    if (condition.$eq) {
+      let [left, right] = condition.$eq, leftVal = this.resolveValue(left, context), rightVal = this.resolveValue(right, context);
+      return smartEquals(leftVal, rightVal);
+    }
+    if (condition.$ne) {
+      let [left, right] = condition.$ne, leftVal = this.resolveValue(left, context), rightVal = this.resolveValue(right, context);
+      return smartNotEquals(leftVal, rightVal);
+    }
+    if (condition.exists) {
+      let testPath = path2.join(context.workspaceRoot, condition.exists);
+      return fsSync.existsSync(testPath);
+    }
+    return condition.platform ? context.platform === condition.platform : !0;
+  }
+  /**
+   * Resolve a value, handling $$variable references
+   */
+  resolveValue(value, context) {
+    if (value.startsWith("$$")) {
+      let varName = value.slice(2);
+      return context.variables[varName];
+    }
+    return value;
+  }
+  /**
+   * Resolve pattern with glob support and priority-based array matching
+   * Returns resolved file paths (glob patterns return multiple files)
+   */
+  async resolveSourcePattern(pattern, context) {
+    if (this.isSwitchExpression(pattern))
+      throw new Error("Cannot resolve SwitchExpression - expression must be resolved first");
+    let narrowedPattern = pattern, result = await this.sourceResolver.resolve(narrowedPattern, {
+      baseDir: context.packageRoot,
+      logWarnings: !0
+    });
+    return {
+      paths: result.paths,
+      warnings: result.warnings
+    };
+  }
+  /**
+   * Resolve target path from source path and patterns
+   * Handles single-level (*) and recursive (**) globs
+   * Strips platform suffixes from filenames (e.g. read-specs.claude.md -> read-specs.md)
+   */
+  resolveTargetFromGlob(sourcePath, fromPattern, toPattern, context) {
+    let relativePath = path2.relative(context.packageRoot, sourcePath);
+    if (toPattern.includes("*")) {
+      if (toPattern.includes("**")) {
+        let targetRel = resolveRecursiveGlobTargetRelativePath(
+          relativePath,
+          fromPattern,
+          toPattern
+        );
+        return path2.join(context.workspaceRoot, targetRel);
+      }
+      let sourceFileName = path2.basename(sourcePath), sourceExt = path2.extname(sourcePath), sourceBase = path2.basename(sourcePath, sourceExt), toParts = toPattern.split("*"), toPrefix = toParts[0], toSuffix = toParts[1] || "", targetExt = toSuffix.startsWith(".") ? toSuffix : sourceExt + toSuffix, targetFileName = sourceBase + targetExt, strippedTargetFileName = stripPlatformSuffixFromFilename(targetFileName), resolvedTo = toPrefix + strippedTargetFileName;
+      return path2.join(context.workspaceRoot, resolvedTo);
+    }
+    return path2.join(context.workspaceRoot, toPattern);
+  }
+  /**
+   * Get pipeline description
+   */
+  getPipeline(flow) {
+    let pipeline = ["load"];
+    return flow.path && pipeline.push("extract"), flow.pick && pipeline.push("pick"), flow.omit && pipeline.push("omit"), flow.map && pipeline.push("map"), flow.embed && pipeline.push("embed"), flow.merge && pipeline.push(`merge:${flow.merge}`), pipeline.push("write"), pipeline;
+  }
+  /**
+   * Normalize from pattern for display in results
+   * Converts array to comma-separated string
+   */
+  normalizeFromPattern(pattern) {
+    if (this.isSwitchExpression(pattern))
+      return "<switch>";
+    let narrowedPattern = pattern;
+    return Array.isArray(narrowedPattern) ? narrowedPattern.join(", ") : narrowedPattern;
+  }
+  /**
+   * Normalize to pattern for display in results
+   * Handles string, multi-target, and switch expressions
+   */
+  normalizeToPattern(pattern) {
+    return typeof pattern == "string" ? pattern : this.isSwitchExpression(pattern) ? "<switch>" : Object.keys(pattern).join(", ");
+  }
+  /**
+   * Get the first pattern from a pattern or array of patterns
+   * Used for path resolution when multiple sources are specified
+   */
+  getFirstPattern(pattern) {
+    if (this.isSwitchExpression(pattern))
+      throw new Error("Cannot get first pattern from SwitchExpression - expression must be resolved first");
+    let narrowedPattern = pattern;
+    return Array.isArray(narrowedPattern) ? narrowedPattern[0] : narrowedPattern;
+  }
+  /**
+   * Aggregate multi-target results
+   */
+  aggregateResults(results, startTime) {
+    let successful = results.filter((r) => r.success), failed = results.filter((r) => !r.success);
+    return failed.length > 0 ? {
+      source: results[0]?.source || "",
+      target: results.map((r) => r.target).join(", "),
+      success: !1,
+      transformed: results.some((r) => r.transformed),
+      error: failed[0]?.error,
+      warnings: results.flatMap((r) => r.warnings || []),
+      executionTime: Date.now() - startTime
+    } : {
+      source: results[0]?.source || "",
+      target: results.flatMap((r) => typeof r.target == "string" ? [r.target] : r.target),
+      success: !0,
+      transformed: results.some((r) => r.transformed),
+      warnings: results.flatMap((r) => r.warnings || []),
+      conflicts: results.flatMap((r) => r.conflicts || []),
+      executionTime: Date.now() - startTime
+    };
+  }
+  /**
+   * Parse markdown with frontmatter
+   */
+  parseMarkdown(content) {
+    return parseMarkdownDocument(content);
+  }
+  /**
+   * Serialize markdown with frontmatter
+   */
+  serializeMarkdown(content) {
+    return serializeMarkdownDocument(content);
+  }
+  /**
+   * Strip JSON comments
+   */
+  stripJSONComments(content) {
+    let result = content.replace(/\/\/.*$/gm, "");
+    return result = result.replace(/\/\*[\s\S]*?\*\//g, ""), result;
+  }
+  /**
+   * Get nested value using dot notation (delegates to key mapper)
+   */
+  getNestedValue(obj, path3) {
+    return getNestedValue(obj, path3);
+  }
+  /**
+   * Set nested value using dot notation (delegates to key mapper)
+   */
+  setNestedValue(obj, path3, value) {
+    setNestedValue(obj, path3, value);
+  }
+  /**
+   * Delete nested value using dot notation (delegates to key mapper)
+   */
+  deleteNestedValue(obj, path3) {
+    deleteNestedValue(obj, path3);
+  }
+  /**
+   * Apply Codex-specific TOML formatting
+   * Converts nested table sections to inline format for http_headers and env_http_headers
+   */
+  applyCodexTomlFormatting(toml) {
+    let inlineKeys = ["http_headers", "env_http_headers"], result = toml;
+    for (let key of inlineKeys) {
+      let pattern = new RegExp(
+        `\\[([\\w-]+(?:\\.[\\w-]+|\\."[^"]+")*)?\\.${key}\\]\\s*\\n([\\s\\S]*?)(?=\\n\\[|\\n*$)`,
+        "g"
+      );
+      result = result.replace(pattern, (match, parentPath, content) => {
+        let pairs = [], lines = content.trim().split(`
+`);
+        for (let line of lines) {
+          let trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith("#")) continue;
+          let kvMatch = trimmed.match(/^([\w-]+)\s*=\s*(.+)$/);
+          if (kvMatch) {
+            let [, k, v] = kvMatch;
+            pairs.push(`"${k}" = ${v}`);
+          }
+        }
+        if (pairs.length === 0) return match;
+        let inlineTable = `{ ${pairs.join(", ")} }`;
+        return `${key} = ${inlineTable}`;
+      });
+    }
+    return result;
+  }
+};
+function createFlowExecutor() {
+  return new DefaultFlowExecutor();
+}
+
+export {
+  calculateFileHash,
+  mergePackageContentIntoRootFile,
+  resolveRecursiveGlobTargetRelativePath,
+  createFlowExecutor
+};
+//# sourceMappingURL=chunk-ELCB4RC2.js.map