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

package/src/workspace/discovery.ts

@@ -1,94 +0,0 @@
-import { join, resolve } from 'node:path';
-import type { WorkspacePackage } from '../graph/types';
-import type {
-  FileSystemClient,
-  GlobClient,
-  YamlClient,
-} from '../types/clients';
-
-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

@@ -1,35 +0,0 @@
-import type { WorkspacePackage } from '../graph/types';
-
-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;
-}

package/src/workspace/package-map.test.ts

@@ -1,95 +0,0 @@
-import { mkdtempSync, mkdirSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, describe, expect, it } from 'vitest';
-import type { WorkspacePackage } from '../graph/types';
-import { buildPackageMap } from './package-map';
-
-const tempDirs: string[] = [];
-
-function createTempRepo(): string {
-  const tempBaseDir = mkdtempSync(
-    join(tmpdir(), 'dependency-graph-package-map-'),
-  );
-  tempDirs.push(tempBaseDir);
-  const rootDir = join(tempBaseDir, 'repo');
-  mkdirSync(rootDir, { recursive: true });
-  return rootDir;
-}
-
-function createWorkspacePackage(path: string, name: string): WorkspacePackage {
-  return {
-    name,
-    version: '0.0.0',
-    path,
-    packageJson: { name },
-    dependencies: {},
-    devDependencies: {},
-  };
-}
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe('buildPackageMap', () => {
-  it('keeps in-repo workspace paths as workflow paths', () => {
-    const rootDir = createTempRepo();
-    const packageDir = join(rootDir, 'apps/web');
-    mkdirSync(packageDir, { recursive: true });
-
-    const { packageMap, workspaceRoots } = buildPackageMap(
-      [createWorkspacePackage(packageDir, 'web')],
-      rootDir,
-    );
-
-    expect(packageMap.get('web')).toEqual({
-      filesystemPath: 'apps/web',
-      workflowPath: 'apps/web',
-    });
-    expect(Array.from(workspaceRoots)).toEqual(['apps']);
-  });
-
-  it('rebases external workspace paths to in-repo mirrors', () => {
-    const rootDir = createTempRepo();
-    mkdirSync(join(rootDir, 'plugins/design-system'), { recursive: true });
-    const externalPackageDir = join(
-      rootDir,
-      '../crossplatform.ai/plugins/design-system',
-    );
-    mkdirSync(externalPackageDir, { recursive: true });
-
-    const { packageMap, workspaceRoots } = buildPackageMap(
-      [createWorkspacePackage(externalPackageDir, '@repo/design-system')],
-      rootDir,
-    );
-
-    expect(packageMap.get('@repo/design-system')).toEqual({
-      filesystemPath: '../crossplatform.ai/plugins/design-system',
-      workflowPath: 'plugins/design-system',
-    });
-    expect(Array.from(workspaceRoots)).toEqual(['plugins']);
-  });
-
-  it('skips workflow paths for external workspaces without local mirrors', () => {
-    const rootDir = createTempRepo();
-    const externalPackageDir = join(
-      rootDir,
-      '../crossplatform.ai/plugins/ghost',
-    );
-    mkdirSync(externalPackageDir, { recursive: true });
-
-    const { packageMap, workspaceRoots } = buildPackageMap(
-      [createWorkspacePackage(externalPackageDir, '@repo/ghost')],
-      rootDir,
-    );
-
-    expect(packageMap.get('@repo/ghost')).toEqual({
-      filesystemPath: '../crossplatform.ai/plugins/ghost',
-      workflowPath: null,
-    });
-    expect(Array.from(workspaceRoots)).toEqual([]);
-  });
-});

package/src/workspace/package-map.ts

@@ -1,74 +0,0 @@
-import { existsSync } from 'node:fs';
-import { join, relative, sep } from 'node:path';
-import type { WorkspacePackage } from '../graph/types';
-
-export interface MappedWorkspacePath {
-  filesystemPath: string;
-  workflowPath: string | null;
-}
-
-export interface WorkspacePackageMap {
-  packageMap: Map<string, MappedWorkspacePath>;
-  workspaceRoots: Set<string>;
-}
-
-export function normalizeRelativePath(path: string): string {
-  return path.split(sep).join('/');
-}
-
-function resolveWorkflowPath(
-  relativePath: string,
-  rootDir: string,
-): string | null {
-  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(join(rootDir, candidatePath))) {
-      return candidatePath;
-    }
-  }
-
-  return null;
-}
-
-export function buildPackageMap(
-  packages: WorkspacePackage[],
-  rootDir: string,
-): WorkspacePackageMap {
-  const packageMap = new Map<string, MappedWorkspacePath>();
-  const workspaceRoots = new Set<string>();
-
-  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,
-  };
-}