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

package/dist/index.js

@@ -0,0 +1,791 @@
+// 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;
+}
+function findDependencyPath(from, to, graph) {
+  const queue = [[from]];
+  const visited = /* @__PURE__ */ new Set([from]);
+  while (queue.length > 0) {
+    const path = queue.shift();
+    const current = path[path.length - 1];
+    if (!current) {
+      continue;
+    }
+    if (current === to) {
+      return path;
+    }
+    const dependents = graph.dependedBy.get(current) || /* @__PURE__ */ new Set();
+    for (const dependent of dependents) {
+      if (!visited.has(dependent)) {
+        visited.add(dependent);
+        queue.push([...path, dependent]);
+      }
+    }
+  }
+  return null;
+}
+function findAllPaths(from, to, graph, maxPaths = 10) {
+  const paths = [];
+  const visited = /* @__PURE__ */ new Set();
+  function dfs(current, path) {
+    if (paths.length >= maxPaths) return;
+    if (current === to) {
+      paths.push([...path]);
+      return;
+    }
+    if (visited.has(current)) return;
+    visited.add(current);
+    const dependents = graph.dependedBy.get(current) || /* @__PURE__ */ new Set();
+    for (const dependent of dependents) {
+      dfs(dependent, [...path, dependent]);
+    }
+    visited.delete(current);
+  }
+  dfs(from, [from]);
+  return paths;
+}
+
+// src/graph/analysis.ts
+function analyzeGraph(graph) {
+  const leafNodes = [];
+  const rootNodes = [];
+  let totalEdges = 0;
+  for (const [pkgName, dependents] of graph.dependedBy.entries()) {
+    if (dependents.size === 0) {
+      leafNodes.push(pkgName);
+    }
+    totalEdges += dependents.size;
+  }
+  for (const [pkgName, dependencies] of graph.dependsOn.entries()) {
+    if (dependencies.size === 0) {
+      rootNodes.push(pkgName);
+    }
+  }
+  const maxDepth = calculateMaxDepth(graph);
+  const cycles = detectCycles(graph);
+  return {
+    totalPackages: graph.packages.size,
+    totalEdges,
+    maxDepth,
+    leafNodes,
+    rootNodes,
+    cycles
+  };
+}
+function calculateMaxDepth(graph) {
+  let maxDepth = 0;
+  for (const pkgName of graph.packages.keys()) {
+    const depth = getPackageDepth(pkgName, graph);
+    if (depth > maxDepth) {
+      maxDepth = depth;
+    }
+  }
+  return maxDepth;
+}
+function getPackageDepth(pkgName, graph, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(pkgName)) return 0;
+  visited.add(pkgName);
+  const dependencies = graph.dependsOn.get(pkgName) || /* @__PURE__ */ new Set();
+  if (dependencies.size === 0) return 0;
+  let maxDepth = 0;
+  for (const dep of dependencies) {
+    const depth = getPackageDepth(dep, graph, new Set(visited));
+    if (depth > maxDepth) {
+      maxDepth = depth;
+    }
+  }
+  return maxDepth + 1;
+}
+function detectCycles(graph) {
+  const cycles = [];
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  function dfs(pkgName, path) {
+    visited.add(pkgName);
+    recursionStack.add(pkgName);
+    path.push(pkgName);
+    const dependencies = graph.dependsOn.get(pkgName) || /* @__PURE__ */ new Set();
+    for (const dep of dependencies) {
+      if (!visited.has(dep)) {
+        dfs(dep, [...path]);
+      } else if (recursionStack.has(dep)) {
+        const cycleStart = path.indexOf(dep);
+        if (cycleStart !== -1) {
+          const cycle = path.slice(cycleStart);
+          cycle.push(dep);
+          cycles.push(cycle);
+        }
+      }
+    }
+    recursionStack.delete(pkgName);
+  }
+  for (const pkgName of graph.packages.keys()) {
+    if (!visited.has(pkgName)) {
+      dfs(pkgName, []);
+    }
+  }
+  return cycles;
+}
+function getTransitiveDependencies(pkgName, graph) {
+  const transitive = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  function collect(current) {
+    if (visited.has(current)) return;
+    visited.add(current);
+    const deps = graph.dependsOn.get(current) || /* @__PURE__ */ new Set();
+    for (const dep of deps) {
+      transitive.add(dep);
+      collect(dep);
+    }
+  }
+  collect(pkgName);
+  return transitive;
+}
+function getTransitiveDependents(pkgName, graph) {
+  const transitive = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  function collect(current) {
+    if (visited.has(current)) return;
+    visited.add(current);
+    const dependents = graph.dependedBy.get(current) || /* @__PURE__ */ new Set();
+    for (const dependent of dependents) {
+      transitive.add(dependent);
+      collect(dependent);
+    }
+  }
+  collect(pkgName);
+  return transitive;
+}
+
+// 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/workspace/file-mapping.ts
+function findPackageForFile(filePath, packages) {
+  const sorted = packages.sort((a, b) => b.path.length - a.path.length);
+  for (const pkg of sorted) {
+    if (filePath.startsWith(pkg.path + "/") || filePath === pkg.path) {
+      return pkg;
+    }
+  }
+  return void 0;
+}
+function mapFilesToPackages(files, packages) {
+  const fileMap = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const pkg = findPackageForFile(file, packages);
+    if (pkg) {
+      if (!fileMap.has(pkg.name)) {
+        fileMap.set(pkg.name, []);
+      }
+      fileMap.get(pkg.name).push(file);
+    }
+  }
+  return fileMap;
+}
+
+// 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)
+          }
+        ]
+      };
+    }
+  });
+}
+export {
+  analyzeGraph,
+  buildDependencyGraph,
+  buildPackageMap,
+  defaultWorkflowValidationPolicy,
+  detectCycles,
+  discoverWorkspaces,
+  findAffectedPackages,
+  findAllPaths,
+  findDependencyPath,
+  findPackageForFile,
+  getTransitiveDependencies,
+  getTransitiveDependents,
+  getWorkflowImpacts,
+  mapFilesToPackages,
+  matchesWorkflowPathFilter,
+  normalizeRelativePath,
+  validateWorkflows
+};
+//# sourceMappingURL=index.js.map