@crossplatformai/dependency-graph 0.9.2

package/src/graph/analysis.ts

@@ -0,0 +1,147 @@
+import type { DependencyGraph, GraphStats } from './types.js';
+
+export function analyzeGraph(graph: DependencyGraph): GraphStats {
+  const leafNodes: string[] = [];
+  const rootNodes: string[] = [];
+  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: DependencyGraph): number {
+  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: string,
+  graph: DependencyGraph,
+  visited = new Set<string>(),
+): number {
+  if (visited.has(pkgName)) return 0;
+  visited.add(pkgName);
+
+  const dependencies = graph.dependsOn.get(pkgName) || 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;
+}
+
+export function detectCycles(graph: DependencyGraph): string[][] {
+  const cycles: string[][] = [];
+  const visited = new Set<string>();
+  const recursionStack = new Set<string>();
+
+  function dfs(pkgName: string, path: string[]): void {
+    visited.add(pkgName);
+    recursionStack.add(pkgName);
+    path.push(pkgName);
+
+    const dependencies = graph.dependsOn.get(pkgName) || 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;
+}
+
+export function getTransitiveDependencies(
+  pkgName: string,
+  graph: DependencyGraph,
+): Set<string> {
+  const transitive = new Set<string>();
+  const visited = new Set<string>();
+
+  function collect(current: string): void {
+    if (visited.has(current)) return;
+    visited.add(current);
+
+    const deps = graph.dependsOn.get(current) || new Set();
+    for (const dep of deps) {
+      transitive.add(dep);
+      collect(dep);
+    }
+  }
+
+  collect(pkgName);
+  return transitive;
+}
+
+export function getTransitiveDependents(
+  pkgName: string,
+  graph: DependencyGraph,
+): Set<string> {
+  const transitive = new Set<string>();
+  const visited = new Set<string>();
+
+  function collect(current: string): void {
+    if (visited.has(current)) return;
+    visited.add(current);
+
+    const dependents = graph.dependedBy.get(current) || new Set();
+    for (const dependent of dependents) {
+      transitive.add(dependent);
+      collect(dependent);
+    }
+  }
+
+  collect(pkgName);
+  return transitive;
+}

package/src/graph/builder.ts

@@ -0,0 +1,52 @@
+import type { WorkspacePackage, DependencyGraph } from './types.js';
+
+export function buildDependencyGraph(
+  packages: WorkspacePackage[],
+): DependencyGraph {
+  const graph: DependencyGraph = {
+    packages: new Map(),
+    dependsOn: new Map(),
+    dependedBy: new Map(),
+  };
+
+  for (const pkg of packages) {
+    graph.packages.set(pkg.name, pkg);
+    graph.dependsOn.set(pkg.name, new Set());
+    graph.dependedBy.set(pkg.name, 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: string,
+  packages: WorkspacePackage[],
+): WorkspacePackage | undefined {
+  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 undefined;
+}

package/src/graph/traversal.ts

@@ -0,0 +1,132 @@
+import type { DependencyGraph, TraversalOptions } from './types.js';
+
+export function findAffectedPackages(
+  startingPackages: Set<string>,
+  graph: DependencyGraph,
+  options: TraversalOptions = {},
+): Set<string> {
+  const {
+    direction = 'upstream',
+    maxDepth = Infinity,
+    filter,
+    respectAffectsUpstream = false,
+  } = options;
+
+  const affected = new Set<string>(startingPackages);
+  const queue: Array<{ name: string; depth: number }> = Array.from(
+    startingPackages,
+  ).map((name) => ({ name, depth: 0 }));
+  const visited = new Set<string>();
+
+  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 = new Set<string>();
+
+    if (direction === 'upstream' || direction === 'both') {
+      const upstream = graph.dependedBy.get(current.name) || new Set();
+      upstream.forEach((p) => nextPackages.add(p));
+    }
+
+    if (direction === 'downstream' || direction === 'both') {
+      const downstream = graph.dependsOn.get(current.name) || 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;
+}
+
+export function findDependencyPath(
+  from: string,
+  to: string,
+  graph: DependencyGraph,
+): string[] | null {
+  const queue: string[][] = [[from]];
+  const visited = new Set<string>([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) || new Set();
+    for (const dependent of dependents) {
+      if (!visited.has(dependent)) {
+        visited.add(dependent);
+        queue.push([...path, dependent]);
+      }
+    }
+  }
+
+  return null;
+}
+
+export function findAllPaths(
+  from: string,
+  to: string,
+  graph: DependencyGraph,
+  maxPaths = 10,
+): string[][] {
+  const paths: string[][] = [];
+  const visited = new Set<string>();
+
+  function dfs(current: string, path: string[]): void {
+    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) || new Set();
+    for (const dependent of dependents) {
+      dfs(dependent, [...path, dependent]);
+    }
+
+    visited.delete(current);
+  }
+
+  dfs(from, [from]);
+  return paths;
+}

package/src/graph/types.ts

@@ -0,0 +1,50 @@
+export interface PackageJson {
+  name: string;
+  version?: string;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  release?: {
+    type?: string;
+    enabled?: boolean;
+    affectsUpstream?: boolean;
+    platform?: string;
+    service?: string;
+    workflow?: string;
+    versioned?: {
+      enabled?: boolean;
+      strategy?: string;
+    };
+  };
+  [key: string]: unknown;
+}
+
+export interface WorkspacePackage {
+  name: string;
+  version: string;
+  path: string;
+  packageJson: PackageJson;
+  dependencies: Record<string, string>;
+  devDependencies: Record<string, string>;
+}
+
+export interface DependencyGraph {
+  packages: Map<string, WorkspacePackage>;
+  dependsOn: Map<string, Set<string>>;
+  dependedBy: Map<string, Set<string>>;
+}
+
+export interface TraversalOptions {
+  direction?: 'upstream' | 'downstream' | 'both';
+  maxDepth?: number;
+  filter?: (pkg: WorkspacePackage) => boolean;
+  respectAffectsUpstream?: boolean;
+}
+
+export interface GraphStats {
+  totalPackages: number;
+  totalEdges: number;
+  maxDepth: number;
+  leafNodes: string[];
+  rootNodes: string[];
+  cycles: string[][];
+}

package/src/index.test.ts

@@ -0,0 +1,94 @@
+import { describe, it, expect } from 'vitest';
+import { buildDependencyGraph } from './graph/builder.js';
+import {
+  findPackageForFile,
+  mapFilesToPackages,
+} from './workspace/file-mapping.js';
+import type { WorkspacePackage } from './graph/types.js';
+
+describe('@repo/dependency-graph', () => {
+  describe('buildDependencyGraph', () => {
+    it('should build a graph from workspace packages', () => {
+      const packages: WorkspacePackage[] = [
+        {
+          name: 'pkg-a',
+          version: '1.0.0',
+          path: '/test/pkg-a',
+          packageJson: { name: 'pkg-a', dependencies: { 'pkg-b': '^1.0.0' } },
+          dependencies: { 'pkg-b': '^1.0.0' },
+          devDependencies: {},
+        },
+        {
+          name: 'pkg-b',
+          version: '1.0.0',
+          path: '/test/pkg-b',
+          packageJson: { name: 'pkg-b' },
+          dependencies: {},
+          devDependencies: {},
+        },
+      ];
+
+      const graph = buildDependencyGraph(packages);
+
+      expect(graph.packages.size).toBe(2);
+      expect(graph.dependsOn.get('pkg-a')).toContain('pkg-b');
+      expect(graph.dependedBy.get('pkg-b')).toContain('pkg-a');
+    });
+  });
+
+  describe('findPackageForFile', () => {
+    it('should find package for file path', () => {
+      const packages: WorkspacePackage[] = [
+        {
+          name: 'pkg-a',
+          version: '1.0.0',
+          path: '/test/pkg-a',
+          packageJson: { name: 'pkg-a' },
+          dependencies: {},
+          devDependencies: {},
+        },
+      ];
+
+      const pkg = findPackageForFile('/test/pkg-a/src/index.ts', packages);
+
+      expect(pkg?.name).toBe('pkg-a');
+    });
+
+    it('should return undefined for unknown file', () => {
+      const packages: WorkspacePackage[] = [];
+
+      const pkg = findPackageForFile('/unknown/file.ts', packages);
+
+      expect(pkg).toBeUndefined();
+    });
+  });
+
+  describe('mapFilesToPackages', () => {
+    it('should map files to packages', () => {
+      const packages: WorkspacePackage[] = [
+        {
+          name: 'pkg-a',
+          version: '1.0.0',
+          path: '/test/pkg-a',
+          packageJson: { name: 'pkg-a' },
+          dependencies: {},
+          devDependencies: {},
+        },
+        {
+          name: 'pkg-b',
+          version: '1.0.0',
+          path: '/test/pkg-b',
+          packageJson: { name: 'pkg-b' },
+          dependencies: {},
+          devDependencies: {},
+        },
+      ];
+
+      const files = ['/test/pkg-a/src/index.ts', '/test/pkg-b/src/other.ts'];
+      const fileMap = mapFilesToPackages(files, packages);
+
+      expect(fileMap.get('pkg-a')).toEqual(['/test/pkg-a/src/index.ts']);
+      expect(fileMap.get('pkg-b')).toEqual(['/test/pkg-b/src/other.ts']);
+    });
+  });
+});

package/src/index.ts

@@ -0,0 +1,40 @@
+export type {
+  WorkspacePackage,
+  DependencyGraph,
+  TraversalOptions,
+  GraphStats,
+  PackageJson,
+} from './graph/types.js';
+
+export type {
+  WorkspaceConfig,
+  WorkspaceDiscoveryConfig,
+} from './workspace/discovery.js';
+
+export type {
+  FileSystemClient,
+  GlobClient,
+  YamlClient,
+} from './types/clients.js';
+
+export { buildDependencyGraph } from './graph/builder.js';
+
+export {
+  findAffectedPackages,
+  findDependencyPath,
+  findAllPaths,
+} from './graph/traversal.js';
+
+export {
+  analyzeGraph,
+  detectCycles,
+  getTransitiveDependencies,
+  getTransitiveDependents,
+} from './graph/analysis.js';
+
+export { discoverWorkspaces } from './workspace/discovery.js';
+
+export {
+  findPackageForFile,
+  mapFilesToPackages,
+} from './workspace/file-mapping.js';

package/src/types/clients.ts

@@ -0,0 +1,19 @@
+export interface FileSystemClient {
+  readFile(path: string, encoding: 'utf-8'): Promise<string>;
+  exists(path: string): Promise<boolean>;
+}
+
+export interface GlobClient {
+  glob(
+    pattern: string,
+    options: {
+      cwd: string;
+      absolute: boolean;
+      ignore?: string[];
+    },
+  ): Promise<string[]>;
+}
+
+export interface YamlClient {
+  parse(content: string): unknown;
+}

package/src/workspace/discovery.ts

@@ -0,0 +1,94 @@
+import { join, resolve } from 'node:path';
+import type { WorkspacePackage } from '../graph/types.js';
+import type {
+  FileSystemClient,
+  GlobClient,
+  YamlClient,
+} from '../types/clients.js';
+
+export interface WorkspaceConfig {
+  packages: string[];
+}
+
+export interface WorkspaceDiscoveryConfig {
+  fs: FileSystemClient;
+  glob: GlobClient;
+  yaml: YamlClient;
+}
+
+export async function discoverWorkspaces(
+  rootDir: string,
+  config: WorkspaceDiscoveryConfig,
+): Promise<WorkspacePackage[]> {
+  const workspaceConfig = await loadWorkspaceConfig(rootDir, config);
+  const packages: WorkspacePackage[] = [];
+
+  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: string = await config.fs.readFile(
+          pkgJsonPath,
+          'utf-8',
+        );
+        const pkgJson = JSON.parse(pkgJsonContent) as {
+          name: string;
+          version?: string;
+          dependencies?: Record<string, string>;
+          devDependencies?: Record<string, string>;
+          [key: string]: unknown;
+        };
+
+        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: string,
+  config: WorkspaceDiscoveryConfig,
+): Promise<WorkspaceConfig> {
+  const workspaceFilePath = join(rootDir, 'pnpm-workspace.yaml');
+
+  try {
+    const content: string = await config.fs.readFile(
+      workspaceFilePath,
+      'utf-8',
+    );
+    const parsed = config.yaml.parse(content) as WorkspaceConfig;
+    return parsed;
+  } catch {
+    return { packages: [] };
+  }
+}
+
+async function findPackageDirectories(
+  rootDir: string,
+  pattern: string,
+  config: WorkspaceDiscoveryConfig,
+): Promise<string[]> {
+  const matches: string[] = await config.glob.glob(pattern, {
+    cwd: rootDir,
+    absolute: false,
+    ignore: ['**/node_modules/**', '**/.next/**', '**/dist/**'],
+  });
+
+  return matches.map((match: string) => resolve(rootDir, match));
+}

package/src/workspace/file-mapping.ts

@@ -0,0 +1,35 @@
+import type { WorkspacePackage } from '../graph/types.js';
+
+export function findPackageForFile(
+  filePath: string,
+  packages: WorkspacePackage[],
+): WorkspacePackage | undefined {
+  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 undefined;
+}
+
+export function mapFilesToPackages(
+  files: string[],
+  packages: WorkspacePackage[],
+): Map<string, string[]> {
+  const fileMap = new Map<string, string[]>();
+
+  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;
+}