Build a Monorepo Package Publisher

// src/publish/monorepo.ts — Monorepo package publisher with dependency resolution
import { readFile, writeFile, readdir } from "node:fs/promises";
import { join } from "node:path";
import { execSync } from "node:child_process";

interface Package {
  name: string;
  version: string;
  path: string;
  dependencies: string[];
  changed: boolean;
  newVersion: string | null;
}

interface PublishPlan {
  packages: Array<{ name: string; currentVersion: string; newVersion: string; changeType: string; order: number }>;
  changelog: string;
  dependencyOrder: string[];
}

// Scan monorepo for packages
export async function scanPackages(rootDir: string): Promise<Package[]> {
  const packagesDir = join(rootDir, "packages");
  const dirs = await readdir(packagesDir, { withFileTypes: true });
  const packages: Package[] = [];

  for (const dir of dirs) {
    if (!dir.isDirectory()) continue;
    const pkgPath = join(packagesDir, dir.name);
    try {
      const pkgJson = JSON.parse(await readFile(join(pkgPath, "package.json"), "utf-8"));
      const deps = Object.keys({ ...pkgJson.dependencies, ...pkgJson.peerDependencies })
        .filter((d) => d.startsWith("@internal/"));

      packages.push({
        name: pkgJson.name,
        version: pkgJson.version,
        path: pkgPath,
        dependencies: deps,
        changed: false,
        newVersion: null,
      });
    } catch {}
  }

  return packages;
}

// Detect changed packages since last publish
export async function detectChanges(packages: Package[], baseBranch: string = "main"): Promise<Package[]> {
  try {
    const diff = execSync(`git diff --name-only ${baseBranch}...HEAD`, { encoding: "utf-8" });
    const changedFiles = diff.split("\n").filter(Boolean);

    for (const pkg of packages) {
      const relativePath = pkg.path.replace(process.cwd() + "/", "");
      pkg.changed = changedFiles.some((f) => f.startsWith(relativePath));
    }

    // Mark packages that depend on changed packages as also changed
    let changed = true;
    while (changed) {
      changed = false;
      for (const pkg of packages) {
        if (pkg.changed) continue;
        if (pkg.dependencies.some((d) => packages.find((p) => p.name === d)?.changed)) {
          pkg.changed = true;
          changed = true;
        }
      }
    }
  } catch {
    // If git diff fails, mark all as changed
    packages.forEach((p) => p.changed = true);
  }

  return packages;
}

// Resolve dependency order (topological sort)
export function resolveDependencyOrder(packages: Package[]): string[] {
  const graph = new Map<string, string[]>();
  const inDegree = new Map<string, number>();

  for (const pkg of packages) {
    graph.set(pkg.name, pkg.dependencies.filter((d) => packages.some((p) => p.name === d)));
    inDegree.set(pkg.name, 0);
  }

  for (const [, deps] of graph) {
    for (const dep of deps) {
      inDegree.set(dep, (inDegree.get(dep) || 0) + 1);
    }
  }

  // Kahn's algorithm (reversed — dependencies first)
  const queue: string[] = [];
  for (const [name, degree] of inDegree) {
    if (degree === 0) queue.push(name);
  }

  // Reverse: publish dependencies first
  const order: string[] = [];
  const visited = new Set<string>();

  function dfs(name: string): void {
    if (visited.has(name)) return;
    visited.add(name);
    const deps = graph.get(name) || [];
    for (const dep of deps) dfs(dep);
    order.push(name);
  }

  for (const pkg of packages) dfs(pkg.name);

  return order;
}

// Create publish plan
export async function createPublishPlan(
  packages: Package[],
  bumpType: "patch" | "minor" | "major" = "patch"
): Promise<PublishPlan> {
  const changedPackages = packages.filter((p) => p.changed);
  const order = resolveDependencyOrder(changedPackages);

  const plan: PublishPlan["packages"] = [];
  let changelog = `# Release ${new Date().toISOString().slice(0, 10)}\n\n`;

  for (let i = 0; i < order.length; i++) {
    const pkg = changedPackages.find((p) => p.name === order[i]);
    if (!pkg) continue;

    const newVersion = bumpVersion(pkg.version, bumpType);
    pkg.newVersion = newVersion;

    plan.push({
      name: pkg.name,
      currentVersion: pkg.version,
      newVersion,
      changeType: bumpType,
      order: i + 1,
    });

    // Get commits for changelog
    try {
      const relativePath = pkg.path.replace(process.cwd() + "/", "");
      const commits = execSync(`git log --oneline main..HEAD -- ${relativePath}`, { encoding: "utf-8" }).trim();
      if (commits) {
        changelog += `## ${pkg.name} (${pkg.version} → ${newVersion})\n`;
        changelog += commits.split("\n").map((c) => `- ${c}`).join("\n") + "\n\n";
      }
    } catch {}
  }

  return { packages: plan, changelog, dependencyOrder: order };
}

// Execute publish
export async function executePublish(plan: PublishPlan, packages: Package[], dryRun: boolean = false): Promise<{
  published: string[]; failed: Array<{ name: string; error: string }>;
}> {
  const published: string[] = [];
  const failed: Array<{ name: string; error: string }> = [];

  for (const entry of plan.packages) {
    const pkg = packages.find((p) => p.name === entry.name);
    if (!pkg) continue;

    try {
      // Update version in package.json
      const pkgJsonPath = join(pkg.path, "package.json");
      const pkgJson = JSON.parse(await readFile(pkgJsonPath, "utf-8"));
      pkgJson.version = entry.newVersion;

      // Update internal dependency versions
      for (const depType of ["dependencies", "peerDependencies"]) {
        if (!pkgJson[depType]) continue;
        for (const [depName, depVersion] of Object.entries(pkgJson[depType] as Record<string, string>)) {
          const depPkg = packages.find((p) => p.name === depName);
          if (depPkg?.newVersion) {
            pkgJson[depType][depName] = `^${depPkg.newVersion}`;
          }
        }
      }

      if (!dryRun) {
        await writeFile(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + "\n");
        execSync("npm publish --access public", { cwd: pkg.path, stdio: "pipe" });
      }

      published.push(`${entry.name}@${entry.newVersion}`);
      console.log(`${dryRun ? "[DRY RUN] " : ""}Published ${entry.name}@${entry.newVersion}`);

    } catch (error: any) {
      failed.push({ name: entry.name, error: error.message });
    }
  }

  return { published, failed };
}

function bumpVersion(version: string, type: "patch" | "minor" | "major"): string {
  const [major, minor, patch] = version.split(".").map(Number);
  switch (type) {
    case "major": return `${major + 1}.0.0`;
    case "minor": return `${major}.${minor + 1}.0`;
    case "patch": return `${major}.${minor}.${patch + 1}`;
  }
}