JimLiu-baoyu-skills/scripts/lib/shared-skill-packages.mjs

import { spawnSync } from "node:child_process";
import { existsSync } from "node:fs";
import fs from "node:fs/promises";
import path from "node:path";

const PACKAGE_DEPENDENCY_SECTIONS = [
  "dependencies",
  "optionalDependencies",
  "peerDependencies",
  "devDependencies",
];

const SKIPPED_DIRS = new Set([".git", ".changeset", ".clawhub", ".clawdhub", "node_modules"]);
const SKIPPED_FILES = new Set([".DS_Store"]);
const TEST_DIR_NAMES = new Set(["__tests__", "test", "tests"]);
const TEST_FILE_PATTERN = /\.(test|spec)\.[^.]+$/;
const CHANGELOG_FILE_PATTERN = /^CHANGELOG(?:\..+)?\.md$/i;
const UNSUPPORTED_FILES_GLOB_PATTERN = /[*?[\]{}!]/;

export async function syncSharedSkillPackages(repoRoot, options = {}) {
  const root = path.resolve(repoRoot);
  const workspacePackages = await discoverWorkspacePackages(root);
  const targetConsumerDirs = normalizeTargetConsumerDirs(root, options.targets ?? []);
  const consumers = await discoverSkillScriptPackages(root, targetConsumerDirs);
  const runtime = options.install === false ? null : resolveBunRuntime();
  const managedPaths = new Set();
  const packageDirs = [];

  for (const consumer of consumers) {
    const result = await syncConsumerPackage({
      consumer,
      root,
      workspacePackages,
      runtime,
    });
    if (!result) continue;

    packageDirs.push(consumer.dir);
    for (const managedPath of result.managedPaths) {
      managedPaths.add(managedPath);
    }
  }

  return {
    packageDirs,
    managedPaths: [...managedPaths].sort(),
  };
}

function normalizeTargetConsumerDirs(repoRoot, targets) {
  if (!targets || targets.length === 0) return null;

  const consumerDirs = new Set();
  for (const target of targets) {
    if (!target) continue;

    const resolvedTarget = path.resolve(repoRoot, target);
    if (path.basename(resolvedTarget) === "scripts") {
      consumerDirs.add(resolvedTarget);
      continue;
    }

    consumerDirs.add(path.join(resolvedTarget, "scripts"));
  }

  return consumerDirs;
}

export function ensureManagedPathsClean(repoRoot, managedPaths) {
  if (managedPaths.length === 0) return;

  const result = spawnSync("git", ["status", "--porcelain", "--", ...managedPaths], {
    cwd: repoRoot,
    encoding: "utf8",
    stdio: ["ignore", "pipe", "pipe"],
  });

  if (result.status !== 0) {
    throw new Error(result.stderr.trim() || "Failed to inspect git status for managed paths");
  }

  const output = result.stdout.trim();
  if (!output) return;

  throw new Error(
    [
      "Shared skill package sync produced uncommitted managed changes.",
      "Review and commit these files before pushing:",
      output,
    ].join("\n"),
  );
}

async function syncConsumerPackage({ consumer, root, workspacePackages, runtime }) {
  const packageJsonPath = path.join(consumer.dir, "package.json");
  const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf8"));
  const localDeps = collectLocalDependencies(packageJson, workspacePackages);
  if (localDeps.length === 0) {
    return null;
  }

  const vendorRoot = path.join(consumer.dir, "vendor");
  await fs.rm(vendorRoot, { recursive: true, force: true });

  for (const name of localDeps) {
    const sourceDir = workspacePackages.get(name);
    if (!sourceDir) continue;
    await syncPackageTree({
      sourceDir,
      targetDir: path.join(vendorRoot, name),
      workspacePackages,
    });
  }

  rewriteLocalDependencySpecs(packageJson, localDeps);
  await writeJson(packageJsonPath, packageJson);

  if (runtime) {
    runInstall(runtime, consumer.dir);
  }

  const managedPaths = [
    path.relative(root, packageJsonPath).split(path.sep).join("/"),
    path.relative(root, path.join(consumer.dir, "bun.lock")).split(path.sep).join("/"),
    path.relative(root, vendorRoot).split(path.sep).join("/"),
  ];

  return { managedPaths };
}

async function syncPackageTree({ sourceDir, targetDir, workspacePackages }) {
  await fs.rm(targetDir, { recursive: true, force: true });
  await fs.mkdir(targetDir, { recursive: true });

  const sourcePackageJsonPath = path.join(sourceDir, "package.json");
  const packageJson = JSON.parse(await fs.readFile(sourcePackageJsonPath, "utf8"));
  const localDeps = collectLocalDependencies(packageJson, workspacePackages);
  await copyPackageContents({ sourceDir, targetDir, packageJson });

  for (const name of localDeps) {
    const nestedSourceDir = workspacePackages.get(name);
    if (!nestedSourceDir) continue;
    await syncPackageTree({
      sourceDir: nestedSourceDir,
      targetDir: path.join(targetDir, "vendor", name),
      workspacePackages,
    });
  }

  rewriteLocalDependencySpecs(packageJson, localDeps);
  await writeJson(path.join(targetDir, "package.json"), packageJson);
}

async function copyDirectory(sourceDir, targetDir) {
  await fs.mkdir(targetDir, { recursive: true });
  const entries = await fs.readdir(sourceDir, { withFileTypes: true });
  for (const entry of entries) {
    if (shouldSkipEntry(entry)) continue;

    const sourcePath = path.join(sourceDir, entry.name);
    const targetPath = path.join(targetDir, entry.name);

    if (entry.isDirectory()) {
      await copyDirectory(sourcePath, targetPath);
      continue;
    }

    if (!entry.isFile()) continue;
    await fs.mkdir(path.dirname(targetPath), { recursive: true });
    await fs.copyFile(sourcePath, targetPath);
  }
}

async function copyPackageContents({ sourceDir, targetDir, packageJson }) {
  const includedPaths = resolveIncludedPackagePaths(packageJson);
  if (!includedPaths) {
    const entries = await fs.readdir(sourceDir, { withFileTypes: true });
    for (const entry of entries) {
      if (shouldSkipEntry(entry)) continue;

      const sourcePath = path.join(sourceDir, entry.name);
      const targetPath = path.join(targetDir, entry.name);

      if (entry.isDirectory()) {
        await copyDirectory(sourcePath, targetPath);
        continue;
      }

      if (!entry.isFile() || entry.name === "package.json") continue;
      await fs.mkdir(path.dirname(targetPath), { recursive: true });
      await fs.copyFile(sourcePath, targetPath);
    }
    return;
  }

  for (const relativePath of includedPaths) {
    const sourcePath = path.join(sourceDir, relativePath);
    const targetPath = path.join(targetDir, relativePath);
    await copyPath(sourcePath, targetPath);
  }
}

async function copyPath(sourcePath, targetPath) {
  let stat;
  try {
    stat = await fs.lstat(sourcePath);
  } catch (error) {
    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return;
    throw error;
  }

  const name = path.basename(sourcePath);
  if (stat.isDirectory()) {
    if (shouldSkipName(name, { isDirectory: true })) return;
    await copyDirectory(sourcePath, targetPath);
    return;
  }

  if (!stat.isFile()) return;
  if (name === "package.json" || shouldSkipName(name, { isFile: true })) return;
  await fs.mkdir(path.dirname(targetPath), { recursive: true });
  await fs.copyFile(sourcePath, targetPath);
}

function resolveIncludedPackagePaths(packageJson) {
  if (!Array.isArray(packageJson.files)) return null;

  const includedPaths = [];
  for (const entry of packageJson.files) {
    if (typeof entry !== "string") continue;

    const normalized = normalizeIncludedPath(entry);
    if (!normalized || normalized === "package.json") continue;
    includedPaths.push(normalized);
  }

  return [...new Set(includedPaths)];
}

function normalizeIncludedPath(entry) {
  const trimmed = entry.trim();
  if (!trimmed) return null;
  if (UNSUPPORTED_FILES_GLOB_PATTERN.test(trimmed)) {
    throw new Error(`Unsupported package.json files entry: ${entry}`);
  }

  const normalized = path.posix.normalize(trimmed.replace(/\\/g, "/")).replace(/^(\.\/)+/, "");
  if (!normalized || normalized === ".") return null;
  if (path.posix.isAbsolute(normalized) || normalized.startsWith("../")) {
    throw new Error(`Package file entry must stay within the package root: ${entry}`);
  }

  return normalized;
}

function shouldSkipEntry(entry) {
  return shouldSkipName(entry.name, {
    isDirectory: entry.isDirectory(),
    isFile: entry.isFile(),
  });
}

function shouldSkipName(name, { isDirectory = false, isFile = false } = {}) {
  if (SKIPPED_DIRS.has(name) || SKIPPED_FILES.has(name)) return true;
  if (isDirectory && TEST_DIR_NAMES.has(name)) return true;
  if (isFile && (TEST_FILE_PATTERN.test(name) || CHANGELOG_FILE_PATTERN.test(name))) return true;
  return false;
}

async function discoverWorkspacePackages(repoRoot) {
  const packagesRoot = path.join(repoRoot, "packages");
  const map = new Map();
  if (!existsSync(packagesRoot)) return map;

  const entries = await fs.readdir(packagesRoot, { withFileTypes: true });
  for (const entry of entries) {
    if (!entry.isDirectory()) continue;
    const packageJsonPath = path.join(packagesRoot, entry.name, "package.json");
    if (!existsSync(packageJsonPath)) continue;

    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf8"));
    if (!packageJson.name) continue;
    map.set(packageJson.name, path.join(packagesRoot, entry.name));
  }

  return map;
}

async function discoverSkillScriptPackages(repoRoot, targetConsumerDirs = null) {
  const skillsRoot = path.join(repoRoot, "skills");
  const consumers = [];
  const skillEntries = await fs.readdir(skillsRoot, { withFileTypes: true });
  for (const entry of skillEntries) {
    if (!entry.isDirectory()) continue;
    const scriptsDir = path.join(skillsRoot, entry.name, "scripts");
    if (targetConsumerDirs && !targetConsumerDirs.has(path.resolve(scriptsDir))) continue;
    const packageJsonPath = path.join(scriptsDir, "package.json");
    if (!existsSync(packageJsonPath)) continue;
    consumers.push({ dir: scriptsDir, packageJsonPath });
  }
  return consumers.sort((left, right) => left.dir.localeCompare(right.dir));
}

function collectLocalDependencies(packageJson, workspacePackages) {
  const localDeps = [];
  for (const section of PACKAGE_DEPENDENCY_SECTIONS) {
    const dependencies = packageJson[section];
    if (!dependencies || typeof dependencies !== "object") continue;

    for (const name of Object.keys(dependencies)) {
      if (!workspacePackages.has(name)) continue;
      localDeps.push(name);
    }
  }

  return [...new Set(localDeps)].sort();
}

function rewriteLocalDependencySpecs(packageJson, localDeps) {
  for (const section of PACKAGE_DEPENDENCY_SECTIONS) {
    const dependencies = packageJson[section];
    if (!dependencies || typeof dependencies !== "object") continue;

    for (const name of localDeps) {
      if (!(name in dependencies)) continue;
      dependencies[name] = `file:./vendor/${name}`;
    }
  }
}

async function writeJson(filePath, value) {
  await fs.mkdir(path.dirname(filePath), { recursive: true });
  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`);
}

function resolveBunRuntime() {
  if (commandExists("bun")) {
    return { command: "bun", args: [] };
  }
  if (commandExists("npx")) {
    return { command: "npx", args: ["-y", "bun"] };
  }
  throw new Error(
    "Neither bun nor npx is installed. Install bun with `brew install oven-sh/bun/bun` or `npm install -g bun`.",
  );
}

function commandExists(command) {
  const result = spawnSync("sh", ["-lc", `command -v ${command}`], {
    stdio: "ignore",
  });
  return result.status === 0;
}

function runInstall(runtime, cwd) {
  const result = spawnSync(runtime.command, [...runtime.args, "install"], {
    cwd,
    stdio: "inherit",
  });

  if (result.status !== 0) {
    throw new Error(`Failed to refresh Bun dependencies in ${cwd}`);
  }
}