@crossplatformai/dependency-graph 0.9.4 → 0.11.0-next.0

package/dist/index-cli.js

@@ -0,0 +1,1172 @@
+#!/usr/bin/env node
+
+// src/cli/pr-preview.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import { glob as glob2 } from "glob";
+import { parse as parseYaml3 } from "yaml";
+
+// src/graph/builder.ts
+function buildDependencyGraph(packages) {
+  const graph = {
+    packages: /* @__PURE__ */ new Map(),
+    dependsOn: /* @__PURE__ */ new Map(),
+    dependedBy: /* @__PURE__ */ new Map()
+  };
+  for (const pkg of packages) {
+    graph.packages.set(pkg.name, pkg);
+    graph.dependsOn.set(pkg.name, /* @__PURE__ */ new Set());
+    graph.dependedBy.set(pkg.name, /* @__PURE__ */ new Set());
+  }
+  for (const pkg of packages) {
+    const allDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+    for (const depName of Object.keys(allDeps)) {
+      const matchedPkg = findMatchingPackage(depName, packages);
+      if (matchedPkg) {
+        graph.dependsOn.get(pkg.name).add(matchedPkg.name);
+        graph.dependedBy.get(matchedPkg.name).add(pkg.name);
+      }
+    }
+  }
+  return graph;
+}
+function findMatchingPackage(depName, packages) {
+  let match = packages.find((p) => p.name === depName);
+  if (match) return match;
+  match = packages.find((p) => p.name === `@repo/${depName}`);
+  if (match) return match;
+  const nameWithoutRepo = depName.replace(/^@repo\//, "");
+  match = packages.find((p) => p.name === nameWithoutRepo);
+  if (match) return match;
+  return void 0;
+}
+
+// src/graph/traversal.ts
+function findAffectedPackages(startingPackages, graph, options = {}) {
+  const {
+    direction = "upstream",
+    maxDepth = Infinity,
+    filter,
+    respectAffectsUpstream = false
+  } = options;
+  const affected = new Set(startingPackages);
+  const queue = Array.from(
+    startingPackages
+  ).map((name) => ({ name, depth: 0 }));
+  const visited = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (visited.has(current.name)) continue;
+    visited.add(current.name);
+    if (current.depth >= maxDepth) {
+      continue;
+    }
+    const pkg = graph.packages.get(current.name);
+    if (!pkg) continue;
+    if (respectAffectsUpstream && direction === "upstream") {
+      const release = pkg.packageJson.release;
+      if (release && release.affectsUpstream === false) {
+        continue;
+      }
+    }
+    const nextPackages = /* @__PURE__ */ new Set();
+    if (direction === "upstream" || direction === "both") {
+      const upstream = graph.dependedBy.get(current.name) || /* @__PURE__ */ new Set();
+      upstream.forEach((p) => nextPackages.add(p));
+    }
+    if (direction === "downstream" || direction === "both") {
+      const downstream = graph.dependsOn.get(current.name) || /* @__PURE__ */ new Set();
+      downstream.forEach((p) => nextPackages.add(p));
+    }
+    for (const pkgName of nextPackages) {
+      const nextPkg = graph.packages.get(pkgName);
+      if (filter && nextPkg && !filter(nextPkg)) {
+        continue;
+      }
+      if (!affected.has(pkgName)) {
+        affected.add(pkgName);
+        queue.push({ name: pkgName, depth: current.depth + 1 });
+      }
+    }
+  }
+  return affected;
+}
+
+// src/workspace/discovery.ts
+import { join, resolve } from "path";
+async function discoverWorkspaces(rootDir, config) {
+  const workspaceConfig = await loadWorkspaceConfig(rootDir, config);
+  const packages = [];
+  for (const pattern of workspaceConfig.packages) {
+    if (pattern.startsWith("!")) continue;
+    const pkgDirs = await findPackageDirectories(rootDir, pattern, config);
+    for (const pkgDir of pkgDirs) {
+      const pkgJsonPath = join(pkgDir, "package.json");
+      try {
+        const pkgJsonContent = await config.fs.readFile(
+          pkgJsonPath,
+          "utf-8"
+        );
+        const pkgJson = JSON.parse(pkgJsonContent);
+        packages.push({
+          name: pkgJson.name,
+          version: pkgJson.version || "0.0.0",
+          path: pkgDir,
+          packageJson: pkgJson,
+          dependencies: pkgJson.dependencies || {},
+          devDependencies: pkgJson.devDependencies || {}
+        });
+      } catch {
+        continue;
+      }
+    }
+  }
+  return packages;
+}
+async function loadWorkspaceConfig(rootDir, config) {
+  const workspaceFilePath = join(rootDir, "pnpm-workspace.yaml");
+  try {
+    const content = await config.fs.readFile(
+      workspaceFilePath,
+      "utf-8"
+    );
+    const parsed = config.yaml.parse(content);
+    return parsed;
+  } catch {
+    return { packages: [] };
+  }
+}
+async function findPackageDirectories(rootDir, pattern, config) {
+  const matches = await config.glob.glob(pattern, {
+    cwd: rootDir,
+    absolute: false,
+    ignore: ["**/node_modules/**", "**/.next/**", "**/dist/**"]
+  });
+  return matches.map((match) => resolve(rootDir, match));
+}
+
+// src/workspace/package-map.ts
+import { existsSync } from "fs";
+import { join as join2, relative, sep } from "path";
+function normalizeRelativePath(path) {
+  return path.split(sep).join("/");
+}
+function resolveWorkflowPath(relativePath, rootDir) {
+  if (!relativePath.startsWith("../")) {
+    return relativePath;
+  }
+  const segments = relativePath.split("/");
+  for (let index = 0; index < segments.length; index += 1) {
+    const candidateSegments = segments.slice(index);
+    if (candidateSegments.length === 0 || candidateSegments[0] === "..") {
+      continue;
+    }
+    const candidatePath = candidateSegments.join("/");
+    if (existsSync(join2(rootDir, candidatePath))) {
+      return candidatePath;
+    }
+  }
+  return null;
+}
+function buildPackageMap(packages, rootDir) {
+  const packageMap = /* @__PURE__ */ new Map();
+  const workspaceRoots = /* @__PURE__ */ new Set();
+  for (const pkg of packages) {
+    const relativePath = normalizeRelativePath(relative(rootDir, pkg.path));
+    const workflowPath = resolveWorkflowPath(relativePath, rootDir);
+    packageMap.set(pkg.name, {
+      filesystemPath: relativePath,
+      workflowPath
+    });
+    if (!workflowPath) {
+      continue;
+    }
+    const [workspaceRoot] = workflowPath.split("/");
+    if (workspaceRoot) {
+      workspaceRoots.add(workspaceRoot);
+    }
+  }
+  return {
+    packageMap,
+    workspaceRoots
+  };
+}
+
+// src/workflow/policy.ts
+var defaultWorkflowValidationPolicy = {
+  workflowFilePatterns: ["deploy-*.yml", "release-*.yml"],
+  allowedRootPaths: [
+    "package.json",
+    "pnpm-lock.yaml",
+    "pnpm-workspace.yaml",
+    "turbo.json"
+  ],
+  includeDevDependenciesForRootPackage: true,
+  includeDevDependenciesTransitively: false
+};
+
+// src/workflow/discovery.ts
+import { existsSync as existsSync2, readdirSync } from "fs";
+import { join as join3 } from "path";
+function patternToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^${escaped.replace(/\*/g, ".*")}$`);
+}
+function discoverWorkflowTargets(rootDir, packages, policy) {
+  const workflowsDir = join3(rootDir, ".github/workflows");
+  if (!existsSync2(workflowsDir)) {
+    return [];
+  }
+  const { packageMap } = buildPackageMap(packages, rootDir);
+  const appPackages = packages.filter(
+    (pkg) => packageMap.get(pkg.name)?.workflowPath?.startsWith("apps/")
+  );
+  const bySlug = /* @__PURE__ */ new Map();
+  for (const pkg of appPackages) {
+    const relativePath = packageMap.get(pkg.name)?.workflowPath;
+    if (!relativePath) {
+      continue;
+    }
+    const slug = relativePath.split("/").at(-1);
+    if (slug) {
+      bySlug.set(slug, pkg.name);
+    }
+  }
+  const allowedPatterns = policy.workflowFilePatterns.map(patternToRegExp);
+  const files = readdirSync(workflowsDir).filter((file) => file.endsWith(".yml")).filter((file) => allowedPatterns.some((pattern) => pattern.test(file)));
+  return files.map((workflowFile) => {
+    const match = /^(?:deploy|release)-(.+)\.yml$/.exec(workflowFile);
+    const targetSlug = match?.[1] ?? workflowFile.replace(/\.yml$/, "");
+    return {
+      workflowFile,
+      workflowPath: `.github/workflows/${workflowFile}`,
+      targetSlug,
+      targetPackage: bySlug.get(targetSlug) ?? null
+    };
+  }).sort((a, b) => a.workflowFile.localeCompare(b.workflowFile));
+}
+
+// src/workflow/expected-paths.ts
+function uniqueSorted(values) {
+  return Array.from(new Set(values)).sort();
+}
+function resolveWorkspaceDependency(dependencyName, packages) {
+  let match = packages.find((pkg) => pkg.name === dependencyName);
+  if (match) {
+    return match;
+  }
+  match = packages.find((pkg) => pkg.name === `@repo/${dependencyName}`);
+  if (match) {
+    return match;
+  }
+  const nameWithoutRepo = dependencyName.replace(/^@repo\//, "");
+  return packages.find((pkg) => pkg.name === nameWithoutRepo);
+}
+function collectWorkspaceDependencyNames(pkg, packages, visited, includeDevDependencies, includeDevDependenciesTransitively) {
+  const collected = /* @__PURE__ */ new Set();
+  const dependencyEntries = Object.entries(pkg.dependencies);
+  const devDependencyEntries = includeDevDependencies ? Object.entries(pkg.devDependencies) : [];
+  for (const [dependencyName] of [
+    ...dependencyEntries,
+    ...devDependencyEntries
+  ]) {
+    const dependency = resolveWorkspaceDependency(dependencyName, packages);
+    if (!dependency || visited.has(dependency.name)) {
+      continue;
+    }
+    visited.add(dependency.name);
+    collected.add(dependency.name);
+    const nestedDependencies = collectWorkspaceDependencyNames(
+      dependency,
+      packages,
+      visited,
+      includeDevDependenciesTransitively,
+      includeDevDependenciesTransitively
+    );
+    for (const nestedDependency of nestedDependencies) {
+      collected.add(nestedDependency);
+    }
+  }
+  return collected;
+}
+function getExpectedWorkflowPaths({
+  workflowTarget,
+  packages,
+  packageMap,
+  policy
+}) {
+  const targetPackageName = workflowTarget.targetPackage;
+  if (!targetPackageName) {
+    return [];
+  }
+  const targetPackage = packages.find((pkg) => pkg.name === targetPackageName);
+  if (!targetPackage) {
+    return [];
+  }
+  const dependencyNames = collectWorkspaceDependencyNames(
+    targetPackage,
+    packages,
+    /* @__PURE__ */ new Set(),
+    policy.includeDevDependenciesForRootPackage,
+    policy.includeDevDependenciesTransitively
+  );
+  const expectedPaths = [];
+  const targetPackagePath = packageMap.get(targetPackageName)?.workflowPath;
+  if (targetPackagePath) {
+    expectedPaths.push(`${targetPackagePath}/**`);
+  }
+  for (const dependencyName of dependencyNames) {
+    const dependencyPath = packageMap.get(dependencyName)?.workflowPath;
+    if (dependencyPath) {
+      expectedPaths.push(`${dependencyPath}/**`);
+    }
+  }
+  return uniqueSorted(expectedPaths);
+}
+
+// src/workflow/impact.ts
+function uniqueSorted2(values) {
+  return Array.from(new Set(values)).sort();
+}
+function mergeWorkflowPolicy(policyOverrides) {
+  return {
+    ...defaultWorkflowValidationPolicy,
+    ...policyOverrides,
+    allowedRootPaths: uniqueSorted2([
+      ...defaultWorkflowValidationPolicy.allowedRootPaths,
+      ...policyOverrides?.allowedRootPaths ?? []
+    ])
+  };
+}
+function matchesWorkflowPathFilter(changedPath, workflowPathFilter) {
+  if (workflowPathFilter === changedPath) {
+    return true;
+  }
+  if (!workflowPathFilter.endsWith("/**")) {
+    return false;
+  }
+  const workflowPrefix = workflowPathFilter.slice(0, -3);
+  return changedPath.startsWith(`${workflowPrefix}/`);
+}
+function getWorkflowImpacts(rootDir, packages, changedPaths, policyOverrides) {
+  const policy = mergeWorkflowPolicy(policyOverrides);
+  const workflowTargets = discoverWorkflowTargets(rootDir, packages, policy);
+  const { packageMap } = buildPackageMap(packages, rootDir);
+  return workflowTargets.map((workflowTarget) => {
+    const calculatedPaths = uniqueSorted2([
+      ...getExpectedWorkflowPaths({
+        workflowTarget,
+        packages,
+        packageMap,
+        policy
+      }),
+      ...policy.allowedRootPaths,
+      workflowTarget.workflowPath
+    ]);
+    const matchedPaths = calculatedPaths.filter(
+      (calculatedPath) => changedPaths.some(
+        (changedPath) => matchesWorkflowPathFilter(changedPath, calculatedPath)
+      )
+    );
+    return {
+      ...workflowTarget,
+      matchedPaths: uniqueSorted2(matchedPaths)
+    };
+  }).filter((workflowImpact) => workflowImpact.matchedPaths.length > 0);
+}
+
+// src/workflow/validator.ts
+import { existsSync as existsSync4 } from "fs";
+import { readFile } from "fs/promises";
+import { glob } from "glob";
+import { parse as parseYaml2 } from "yaml";
+
+// src/workflow/parser.ts
+import { existsSync as existsSync3, readFileSync } from "fs";
+import { join as join4 } from "path";
+import { parse as parseYaml } from "yaml";
+function uniqueSorted3(values) {
+  return Array.from(new Set(values)).sort();
+}
+function parseWorkflowFile(workflowFile, rootDir) {
+  const workflowPath = join4(rootDir, ".github/workflows", workflowFile);
+  if (!existsSync3(workflowPath)) {
+    throw new Error(`Workflow file not found: ${workflowFile}`);
+  }
+  const content = readFileSync(workflowPath, "utf-8");
+  const workflow = parseYaml(content);
+  const pushPaths = workflow.on?.push?.paths ?? [];
+  const pullRequestPaths = workflow.on?.pull_request?.paths ?? [];
+  const parsedWorkflow = {
+    pushPaths: uniqueSorted3(pushPaths),
+    pullRequestPaths: uniqueSorted3(pullRequestPaths),
+    paths: uniqueSorted3([...pushPaths, ...pullRequestPaths])
+  };
+  if (workflow.name) {
+    parsedWorkflow.name = workflow.name;
+  }
+  return parsedWorkflow;
+}
+
+// src/workflow/validator.ts
+function uniqueSorted4(values) {
+  return Array.from(new Set(values)).sort();
+}
+function buildBroadWildcards(workspaceRoots) {
+  const wildcards = /* @__PURE__ */ new Set();
+  for (const root of workspaceRoots) {
+    wildcards.add(`${root}/*`);
+    wildcards.add(`${root}/**`);
+  }
+  return wildcards;
+}
+function splitActualPaths(paths, workspaceRoots, allowedRootPaths, workflowPath) {
+  const workspacePaths = [];
+  const ignoredPaths = [];
+  for (const path of paths) {
+    if (path === workflowPath || allowedRootPaths.includes(path)) {
+      ignoredPaths.push(path);
+      continue;
+    }
+    const [rootSegment] = path.split("/");
+    if (rootSegment && workspaceRoots.has(rootSegment)) {
+      workspacePaths.push(path);
+      continue;
+    }
+    ignoredPaths.push(path);
+  }
+  return {
+    workspacePaths: uniqueSorted4(workspacePaths),
+    ignoredPaths: uniqueSorted4(ignoredPaths)
+  };
+}
+function isCoveredByExpectedPath(actualPath, expectedPaths) {
+  return expectedPaths.some((expectedPath) => {
+    if (expectedPath === actualPath) {
+      return true;
+    }
+    if (!expectedPath.endsWith("/**")) {
+      return false;
+    }
+    const expectedPrefix = expectedPath.slice(0, -3);
+    return actualPath.startsWith(`${expectedPrefix}/`);
+  });
+}
+function validateWorkflowResult(workflow, targetPackage, expectedPaths, actualPaths, broadWildcards) {
+  const issues = [];
+  const missing = expectedPaths.filter((path) => !actualPaths.includes(path));
+  const unnecessary = actualPaths.filter(
+    (path) => !isCoveredByExpectedPath(path, expectedPaths)
+  );
+  for (const path of missing) {
+    issues.push({
+      kind: "missing",
+      path,
+      message: `Missing path '${path}'`
+    });
+  }
+  for (const path of unnecessary) {
+    issues.push({
+      kind: "unnecessary",
+      path,
+      message: `Unnecessary path '${path}'`
+    });
+  }
+  for (const path of actualPaths) {
+    if (broadWildcards.has(path)) {
+      issues.push({
+        kind: "broad-wildcard",
+        path,
+        message: `Uses broad wildcard '${path}' which triggers on all workspace changes under that root`
+      });
+    }
+  }
+  return {
+    workflow,
+    targetPackage,
+    valid: issues.length === 0,
+    expectedPaths,
+    actualPaths,
+    missing,
+    unnecessary,
+    issues
+  };
+}
+async function validateWorkflows(rootDir, policyOverrides) {
+  const discoveredPackages = await discoverWorkspaces(rootDir, {
+    fs: {
+      readFile: (path, encoding) => readFile(path, encoding),
+      exists: (path) => Promise.resolve(existsSync4(path))
+    },
+    glob: {
+      glob: (pattern, options) => glob(pattern, options)
+    },
+    yaml: {
+      parse: (content) => parseYaml2(content)
+    }
+  });
+  const policy = {
+    ...defaultWorkflowValidationPolicy,
+    ...policyOverrides,
+    allowedRootPaths: uniqueSorted4([
+      ...defaultWorkflowValidationPolicy.allowedRootPaths,
+      ...policyOverrides?.allowedRootPaths ?? []
+    ])
+  };
+  const { packageMap, workspaceRoots } = buildPackageMap(
+    discoveredPackages,
+    rootDir
+  );
+  const workflowTargets = discoverWorkflowTargets(
+    rootDir,
+    discoveredPackages,
+    policy
+  );
+  const broadWildcards = buildBroadWildcards(workspaceRoots);
+  return workflowTargets.map((workflowTarget) => {
+    if (!workflowTarget.targetPackage) {
+      return {
+        workflow: workflowTarget.workflowFile,
+        targetPackage: workflowTarget.targetSlug,
+        valid: false,
+        expectedPaths: [],
+        actualPaths: [],
+        missing: [],
+        unnecessary: [],
+        issues: [
+          {
+            kind: "config-error",
+            message: `Could not resolve workflow target package for '${workflowTarget.workflowFile}'`
+          }
+        ]
+      };
+    }
+    try {
+      const parsedWorkflow = parseWorkflowFile(
+        workflowTarget.workflowFile,
+        rootDir
+      );
+      if (parsedWorkflow.paths.length === 0) {
+        return {
+          workflow: workflowTarget.workflowFile,
+          targetPackage: workflowTarget.targetPackage,
+          valid: true,
+          expectedPaths: [],
+          actualPaths: [],
+          missing: [],
+          unnecessary: [],
+          issues: []
+        };
+      }
+      const { workspacePaths: actualPaths } = splitActualPaths(
+        parsedWorkflow.paths,
+        workspaceRoots,
+        policy.allowedRootPaths,
+        workflowTarget.workflowPath
+      );
+      const expectedPaths = getExpectedWorkflowPaths({
+        workflowTarget,
+        packages: discoveredPackages,
+        packageMap,
+        policy
+      });
+      return validateWorkflowResult(
+        workflowTarget.workflowFile,
+        workflowTarget.targetPackage,
+        expectedPaths,
+        actualPaths,
+        broadWildcards
+      );
+    } catch (error) {
+      return {
+        workflow: workflowTarget.workflowFile,
+        targetPackage: workflowTarget.targetPackage,
+        valid: false,
+        expectedPaths: [],
+        actualPaths: [],
+        missing: [],
+        unnecessary: [],
+        issues: [
+          {
+            kind: "parse-error",
+            message: error instanceof Error ? error.message : String(error)
+          }
+        ]
+      };
+    }
+  });
+}
+
+// src/cli/pr-preview.ts
+var PLATFORM_INDICATORS = [
+  {
+    platform: "cloudflare-workers",
+    indicators: [{ file: "wrangler.toml" }]
+  },
+  {
+    platform: "expo",
+    indicators: [{ file: "app.json" }, { file: "eas.json" }]
+  },
+  {
+    platform: "npm-package",
+    indicators: [{ field: "bin" }]
+  },
+  {
+    platform: "electron",
+    indicators: [
+      { dependency: "electron" },
+      { dependency: "electron-builder" }
+    ]
+  },
+  {
+    platform: "next.js",
+    indicators: [
+      { file: "next.config.js" },
+      { file: "next.config.mjs" },
+      { file: "next.config.ts" },
+      { dependency: "next" }
+    ]
+  },
+  {
+    platform: "node.js",
+    indicators: [
+      { field: "start" }
+      // has start script
+    ]
+  }
+];
+var DEFAULT_APP_DIRECTORIES = ["apps"];
+function formatWorkflowPathDrift(validationResults) {
+  const invalidResults = validationResults.filter((result) => !result.valid);
+  if (invalidResults.length === 0) {
+    return [];
+  }
+  const lines = [
+    "\u26A0\uFE0F Workflow path drift (advisory - does not affect impact above):"
+  ];
+  for (const result of invalidResults) {
+    lines.push(`  ${result.workflow} (${result.targetPackage}):`);
+    for (const issue of result.issues) {
+      if (issue.kind === "missing") {
+        lines.push(`    + ${issue.message}`);
+      } else if (issue.kind === "unnecessary") {
+        lines.push(`    - ${issue.message}`);
+      } else {
+        lines.push(`    ! ${issue.message}`);
+      }
+    }
+  }
+  return lines;
+}
+function isDeployableApp(pkg) {
+  const isInAppDirectory = DEFAULT_APP_DIRECTORIES.some(
+    (dir) => pkg.path.includes(`/${dir}/`) || pkg.path.endsWith(`/${dir}`)
+  );
+  if (!isInAppDirectory) {
+    return { deployable: false };
+  }
+  for (const platformDetection of PLATFORM_INDICATORS) {
+    const hasIndicators = platformDetection.indicators.some((indicator) => {
+      if (indicator.file) {
+        try {
+          const filePath = resolve2(pkg.path, indicator.file);
+          readFileSync2(filePath, "utf-8");
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      if (indicator.field) {
+        const scripts = pkg.packageJson.scripts;
+        if (indicator.field === "start" && scripts?.start) {
+          return true;
+        }
+        const packageJsonField = pkg.packageJson[indicator.field];
+        if (indicator.field !== "start" && packageJsonField) {
+          return true;
+        }
+      }
+      if (indicator.dependency) {
+        return !!(pkg.dependencies[indicator.dependency] || pkg.devDependencies[indicator.dependency]);
+      }
+      return false;
+    });
+    if (hasIndicators) {
+      return { deployable: true, platform: platformDetection.platform };
+    }
+  }
+  return { deployable: false };
+}
+async function getChangedFiles() {
+  const { execSync } = await import("child_process");
+  try {
+    let baseBranch = "production";
+    try {
+      execSync("git rev-parse production", {
+        encoding: "utf-8",
+        stdio: "pipe"
+      });
+    } catch {
+      baseBranch = "origin/production";
+    }
+    const output = execSync(`git diff --name-status ${baseBranch}...HEAD`, {
+      encoding: "utf-8"
+    });
+    return output.trim().split("\n").filter((line) => line).map((line) => {
+      const [status, path] = line.split("	");
+      return {
+        path: path ?? "",
+        status: status === "D" ? "deleted" : status === "A" ? "added" : "modified"
+      };
+    }).filter((file) => file.path !== "");
+  } catch {
+    console.error(
+      "Failed to get changed files. Ensure you are on a branch with commits compared to production."
+    );
+    process.exit(1);
+  }
+}
+async function runPrPreview() {
+  try {
+    const rootDir = resolve2(process.cwd());
+    const changedFiles = await getChangedFiles();
+    console.log(
+      `
+\u{1F4E6} Release Preview - Changed Files: ${changedFiles.length}
+`
+    );
+    changedFiles.forEach((file) => {
+      console.log(`  ${file.status === "deleted" ? "\u274C" : "\u{1F4DD}"} ${file.path}`);
+    });
+    const packages = await discoverWorkspaces(rootDir, {
+      fs: {
+        readFile: (path) => {
+          try {
+            return Promise.resolve(readFileSync2(path, "utf-8"));
+          } catch {
+            return Promise.reject(new Error(`Failed to read file: ${path}`));
+          }
+        },
+        exists: (path) => {
+          try {
+            readFileSync2(path, "utf-8");
+            return Promise.resolve(true);
+          } catch {
+            return Promise.resolve(false);
+          }
+        }
+      },
+      glob: {
+        glob: async (pattern, options) => glob2(pattern, options)
+      },
+      yaml: {
+        parse: (content) => parseYaml3(content)
+      }
+    });
+    const graph = buildDependencyGraph(packages);
+    const changedPackages = /* @__PURE__ */ new Set();
+    for (const file of changedFiles) {
+      if (file.status === "deleted") continue;
+      const pkg = packages.find((p) => {
+        const relativePkgPath = p.path.replace(rootDir + "/", "");
+        return file.path.startsWith(relativePkgPath);
+      });
+      if (pkg) {
+        changedPackages.add(pkg.name);
+      }
+    }
+    const workflowImpacts = getWorkflowImpacts(
+      rootDir,
+      packages,
+      changedFiles.map((file) => file.path)
+    );
+    const workflowDriftLines = formatWorkflowPathDrift(
+      await validateWorkflows(rootDir)
+    );
+    const workflowAffectedApps = new Set(
+      workflowImpacts.map(
+        (workflowImpact) => workflowImpact.targetPackage ?? workflowImpact.targetSlug
+      )
+    );
+    console.log(
+      `
+\u{1F4E6} Changed packages: ${Array.from(changedPackages).join(", ") || "none"}
+`
+    );
+    if (changedPackages.size === 0 && workflowAffectedApps.size === 0) {
+      console.log(
+        "\n\u2728 No packages or workflow filters changed - no deployments needed\n"
+      );
+      if (workflowDriftLines.length > 0) {
+        console.log(workflowDriftLines.join("\n"));
+        console.log("");
+      }
+      return;
+    }
+    const affected = findAffectedPackages(changedPackages, graph, {
+      direction: "upstream",
+      respectAffectsUpstream: true
+    });
+    const allDeployableApps = packages.map((pkg) => {
+      const detection = isDeployableApp(pkg);
+      return detection.deployable ? { name: pkg.name, pkg, platform: detection.platform } : null;
+    }).filter(
+      (item) => item !== null
+    );
+    const affectedApps = allDeployableApps.filter(
+      (app) => affected.has(app.name) || workflowAffectedApps.has(app.name)
+    );
+    const unaffectedApps = allDeployableApps.filter(
+      (app) => !affected.has(app.name) && !workflowAffectedApps.has(app.name)
+    );
+    const getAppCategory = (platform) => {
+      switch (platform) {
+        case "next.js":
+        case "cloudflare-workers":
+        case "node.js":
+          return "deploy";
+        case "expo":
+        case "electron":
+        case "npm-package":
+          return "release";
+        default:
+          return "deploy";
+      }
+    };
+    const getAppIcon = (platform) => {
+      switch (platform) {
+        case "next.js":
+        case "cloudflare-workers":
+        case "node.js":
+          return "\u{1F310}";
+        case "expo":
+          return "\u{1F4F1}";
+        case "electron":
+          return "\u{1F5A5}\uFE0F";
+        case "npm-package":
+          return "\u26A1";
+        default:
+          return "\u{1F310}";
+      }
+    };
+    const affectedDeploys = affectedApps.filter(
+      (app) => getAppCategory(app.platform) === "deploy"
+    );
+    const affectedReleases = affectedApps.filter(
+      (app) => getAppCategory(app.platform) === "release"
+    );
+    console.log(`
+\u{1F680} PR Preview
+`);
+    if (affectedApps.length === 0) {
+      console.log("No apps affected by changes.\n");
+    } else {
+      if (affectedDeploys.length > 0) {
+        console.log("\u{1F4CB} Apps that will be DEPLOYED:");
+        for (const item of affectedDeploys) {
+          const platformDisplay = item.platform === "generic" ? "" : ` (${item.platform})`;
+          const icon = getAppIcon(item.platform);
+          console.log(`${icon} ${item.name}${platformDisplay}`);
+        }
+        console.log("");
+      }
+      if (affectedReleases.length > 0) {
+        console.log("\u{1F4CB} Apps that will be RELEASED:");
+        for (const item of affectedReleases) {
+          const platformDisplay = item.platform === "generic" ? "" : ` (${item.platform})`;
+          const icon = getAppIcon(item.platform);
+          console.log(`${icon} ${item.name}${platformDisplay}`);
+        }
+        console.log("");
+      }
+    }
+    if (unaffectedApps.length > 0) {
+      console.log(`\u{1F4CB} Apps that will NOT be affected:`);
+      for (const item of unaffectedApps) {
+        const platformDisplay = item.platform === "generic" ? "" : ` (${item.platform})`;
+        console.log(`\u23ED\uFE0F ${item.name}${platformDisplay}`);
+      }
+      console.log("");
+    }
+    console.log(`Legend:`);
+    console.log(`\u{1F310} = Deploy (web-based, instant updates)`);
+    console.log(`\u{1F4F1} = Release (mobile app, user installs)`);
+    console.log(`\u{1F5A5}\uFE0F = Release (desktop app, user installs)`);
+    console.log(`\u26A1 = Release (CLI tool, user installs)`);
+    console.log(`\u23ED\uFE0F = Unaffected (no changes needed)`);
+    console.log(`\u{1F4DD} = File changed`);
+    console.log(`\u274C = File deleted
+`);
+    if (workflowDriftLines.length > 0) {
+      console.log(workflowDriftLines.join("\n"));
+      console.log("");
+    }
+  } catch (error) {
+    console.error(
+      "Error:",
+      error instanceof Error ? error.message : String(error)
+    );
+    process.exit(1);
+  }
+}
+if (import.meta.url === new URL(process.argv[1] ?? "", "file:").href) {
+  void runPrPreview();
+}
+
+// src/cli/validate-workflows.ts
+import { existsSync as existsSync5, readFileSync as readFileSync3, readdirSync as readdirSync2 } from "fs";
+import { join as join5, resolve as resolve3 } from "path";
+import { parse as parseYaml4 } from "yaml";
+function discoverPnpmWorkflows(rootDir) {
+  const workflowsDir = join5(rootDir, ".github/workflows");
+  if (!existsSync5(workflowsDir)) {
+    return [];
+  }
+  const workflows = [];
+  const files = readdirSync2(workflowsDir).filter(
+    (file) => file.endsWith(".yml")
+  );
+  for (const file of files) {
+    const content = readFileSync3(join5(workflowsDir, file), "utf-8");
+    if (content.includes("pnpm/action-setup")) {
+      workflows.push(file);
+    }
+  }
+  return workflows;
+}
+function discoverPnpmDockerfiles(rootDir) {
+  const dockerfiles = [];
+  for (const entry of readdirSync2(rootDir)) {
+    if (!entry.startsWith("Dockerfile")) {
+      continue;
+    }
+    const content = readFileSync3(join5(rootDir, entry), "utf-8");
+    if (content.includes("pnpm@")) {
+      dockerfiles.push(entry);
+    }
+  }
+  const appsDir = join5(rootDir, "apps");
+  if (!existsSync5(appsDir)) {
+    return dockerfiles;
+  }
+  for (const entry of readdirSync2(appsDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const dockerfilePath = join5(appsDir, entry.name, "Dockerfile");
+    if (!existsSync5(dockerfilePath)) {
+      continue;
+    }
+    const content = readFileSync3(dockerfilePath, "utf-8");
+    if (content.includes("pnpm@")) {
+      dockerfiles.push(`apps/${entry.name}/Dockerfile`);
+    }
+  }
+  return dockerfiles;
+}
+function getExpectedPnpmVersion(rootDir) {
+  const packageJson = JSON.parse(
+    readFileSync3(join5(rootDir, "package.json"), "utf-8")
+  );
+  const packageManager = packageJson.packageManager;
+  if (!packageManager?.startsWith("pnpm@")) {
+    throw new Error("packageManager field must specify pnpm version");
+  }
+  return packageManager.replace("pnpm@", "");
+}
+function checkWorkflowPnpmVersion(workflowFile, rootDir) {
+  const workflowPath = join5(rootDir, ".github/workflows", workflowFile);
+  if (!existsSync5(workflowPath)) {
+    return { valid: true };
+  }
+  const content = readFileSync3(workflowPath, "utf-8");
+  const workflow = parseYaml4(content);
+  for (const job of Object.values(workflow.jobs ?? {})) {
+    for (const step of job.steps ?? []) {
+      if (!step.uses?.startsWith("pnpm/action-setup")) {
+        continue;
+      }
+      const version = step.with?.version;
+      if (version !== void 0 && !/^\d+$/.test(String(version))) {
+        return {
+          valid: false,
+          issue: `Hardcoded pnpm version '${version}' - remove 'version' key to auto-detect from packageManager`
+        };
+      }
+    }
+  }
+  return { valid: true };
+}
+function checkDockerfilePnpmVersion(dockerfile, expectedVersion, rootDir) {
+  const dockerfilePath = join5(rootDir, dockerfile);
+  if (!existsSync5(dockerfilePath)) {
+    return { valid: true };
+  }
+  const content = readFileSync3(dockerfilePath, "utf-8");
+  const matches = content.matchAll(/npm install -g pnpm@([\d.]+)/g);
+  for (const match of matches) {
+    if (match[1] !== expectedVersion) {
+      return {
+        valid: false,
+        issue: `${dockerfile} uses pnpm@${match[1]} but package.json specifies pnpm@${expectedVersion}`
+      };
+    }
+  }
+  return { valid: true };
+}
+function validatePnpmVersions(rootDir) {
+  const result = {
+    valid: true,
+    workflowIssues: [],
+    dockerfileIssues: []
+  };
+  for (const workflowFile of discoverPnpmWorkflows(rootDir)) {
+    const check = checkWorkflowPnpmVersion(workflowFile, rootDir);
+    if (!check.valid && check.issue) {
+      result.valid = false;
+      result.workflowIssues.push({
+        workflow: workflowFile,
+        issue: check.issue
+      });
+    }
+  }
+  const expectedVersion = getExpectedPnpmVersion(rootDir);
+  for (const dockerfile of discoverPnpmDockerfiles(rootDir)) {
+    const check = checkDockerfilePnpmVersion(
+      dockerfile,
+      expectedVersion,
+      rootDir
+    );
+    if (!check.valid && check.issue) {
+      result.valid = false;
+      result.dockerfileIssues.push({ dockerfile, issue: check.issue });
+    }
+  }
+  return result;
+}
+function printResult(result) {
+  const icon = result.valid ? "\u2705" : "\u274C";
+  console.log(`
+${icon} ${result.workflow} (${result.targetPackage})`);
+  if (result.valid) {
+    console.log("   All paths match dependencies");
+    return;
+  }
+  const extraIssues = result.issues.filter(
+    (issue) => issue.kind !== "missing" && issue.kind !== "unnecessary"
+  );
+  if (extraIssues.length > 0) {
+    console.log("   Issues:");
+    for (const issue of extraIssues) {
+      console.log(`     \u26A0\uFE0F  ${issue.message}`);
+    }
+  }
+  if (result.missing.length > 0) {
+    console.log("   Missing paths:");
+    for (const path of result.missing) {
+      console.log(`     - ${path}`);
+    }
+  }
+  if (result.unnecessary.length > 0) {
+    console.log("   Unnecessary paths:");
+    for (const path of result.unnecessary) {
+      console.log(`     - ${path}`);
+    }
+  }
+}
+async function runValidateWorkflows() {
+  const rootDir = resolve3(process.cwd());
+  let hasErrors = false;
+  console.log(
+    "\u{1F50D} Validating GitHub Actions workflows against dependencies...\n"
+  );
+  const results = await validateWorkflows(rootDir);
+  console.log(`Found ${results.length} workflow(s) to validate
+`);
+  if (results.length === 0) {
+    console.log("No deploy-*.yml or release-*.yml workflows found.\n");
+  }
+  for (const result of results) {
+    printResult(result);
+  }
+  const validCount = results.filter((result) => result.valid).length;
+  const invalidCount = results.length - validCount;
+  console.log("\n" + "=".repeat(60));
+  console.log(
+    `
+\u{1F4CA} Path validation: ${validCount} valid, ${invalidCount} invalid
+`
+  );
+  if (invalidCount > 0) {
+    console.log("\u274C Some workflows need updates to match dependencies");
+    console.log("\nTo fix:");
+    console.log("1. Update workflow path filters to match missing paths");
+    console.log("2. Remove unnecessary paths");
+    console.log("3. Replace broad workspace wildcards with specific paths\n");
+    hasErrors = true;
+  } else if (results.length > 0) {
+    console.log("\u2705 All workflows match their dependencies!\n");
+  }
+  console.log("=".repeat(60));
+  console.log("\n\u{1F50D} Validating pnpm version consistency...\n");
+  const pnpmResult = validatePnpmVersions(rootDir);
+  if (!pnpmResult.valid) {
+    console.log("\u274C PNPM version issues found:\n");
+    for (const { workflow, issue } of pnpmResult.workflowIssues) {
+      console.log(`   \u26A0\uFE0F  ${workflow}: ${issue}`);
+    }
+    for (const { issue } of pnpmResult.dockerfileIssues) {
+      console.log(`   \u26A0\uFE0F  ${issue}`);
+    }
+    console.log("\nTo fix:");
+    console.log(
+      "1. Remove hardcoded pnpm versions from workflows (let pnpm/action-setup auto-detect from packageManager)"
+    );
+    console.log(
+      "2. Update Dockerfile pnpm versions to match package.json packageManager field\n"
+    );
+    hasErrors = true;
+  } else {
+    console.log("\u2705 PNPM versions are consistent!\n");
+  }
+  if (hasErrors) {
+    process.exit(1);
+  }
+}
+if (import.meta.url === new URL(process.argv[1] ?? "", "file:").href) {
+  void runValidateWorkflows();
+}
+
+// src/cli/index.ts
+function printHelp() {
+  console.log(`dependency-graph <command>
+
+Commands:
+  pr-preview           Show affected deploys and releases for the current branch
+  validate-workflows   Validate workflow path filters and pnpm version consistency`);
+}
+async function main() {
+  const command = process.argv[2];
+  switch (command) {
+    case "pr-preview":
+      await runPrPreview();
+      return;
+    case "validate-workflows":
+      await runValidateWorkflows();
+      return;
+    case "--help":
+    case "-h":
+    case void 0:
+      printHelp();
+      return;
+    default:
+      console.error(`Unknown dependency-graph command: ${command}`);
+      printHelp();
+      process.exit(1);
+  }
+}
+void main();
+//# sourceMappingURL=index-cli.js.map