@seorii/libcollect 0.1.0

package/include-deps.mjs

@@ -0,0 +1,722 @@
+#!/usr/bin/env node
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import semver from "semver";
+
+const DEFAULT_CONCURRENCY = 10;
+const DEFAULT_SOURCE_SECTIONS = ["dependencies", "optionalDependencies", "peerDependencies"];
+const DEFAULT_INCLUDE_TYPES = ["peerDependency", "optionalDependency", "bundledDependency"];
+const REGISTRY_BASE = "https://registry.npmjs.org";
+
+function createLimiter(maxConcurrency) {
+  let activeCount = 0;
+  const queue = [];
+
+  const next = () => {
+    while (activeCount < maxConcurrency && queue.length > 0) {
+      const job = queue.shift();
+      activeCount += 1;
+
+      Promise.resolve()
+        .then(job.fn)
+        .then(job.resolve, job.reject)
+        .finally(() => {
+          activeCount -= 1;
+          next();
+        });
+    }
+  };
+
+  return function limit(fn) {
+    return new Promise((resolve, reject) => {
+      queue.push({ fn, resolve, reject });
+      next();
+    });
+  };
+}
+
+function createRegistryContext(concurrency = DEFAULT_CONCURRENCY) {
+  const safeConcurrency =
+    Number.isFinite(concurrency) && concurrency > 0 ? Math.floor(concurrency) : DEFAULT_CONCURRENCY;
+
+  return {
+    concurrency: safeConcurrency,
+    fetchLimit: createLimiter(safeConcurrency),
+    metaCache: new Map(),
+    resolvedCache: new Map(),
+  };
+}
+
+async function fetchJson(url, registryContext) {
+  return registryContext.fetchLimit(async () => {
+    const res = await fetch(url, {
+      headers: { accept: "application/json" },
+    });
+
+    if (!res.ok) {
+      throw new Error(`HTTP ${res.status} for ${url}`);
+    }
+
+    return res.json();
+  });
+}
+
+async function getPackageMeta(name, registryContext) {
+  if (registryContext.metaCache.has(name)) {
+    return registryContext.metaCache.get(name);
+  }
+
+  const promise = (async () => {
+    const encoded = encodeURIComponent(name);
+    return fetchJson(`${REGISTRY_BASE}/${encoded}`, registryContext);
+  })();
+
+  registryContext.metaCache.set(name, promise);
+  return promise;
+}
+
+function parseAliasSpec(range) {
+  const s = String(range || "").trim();
+  const m = s.match(/^npm:((?:@[^/]+\/)?[^@]+)(?:@(.+))?$/);
+  if (!m) return null;
+
+  return {
+    targetName: m[1],
+    targetRange: m[2] || "latest",
+  };
+}
+
+function isNonRegistrySpec(range) {
+  const s = String(range || "").trim();
+  if (!s || s === "*" || s === "latest") return false;
+  return /^(file:|link:|workspace:|git\+|github:|https?:)/.test(s);
+}
+
+function rangeMentionsPrerelease(range) {
+  return /-\w/.test(String(range || ""));
+}
+
+function getAllVersions(meta) {
+  return Object.keys(meta.versions || {})
+    .filter((version) => !!semver.valid(version))
+    .sort(semver.rcompare);
+}
+
+function pickVersionFromMeta(meta, wanted) {
+  const versions = getAllVersions(meta);
+  const distTags = meta["dist-tags"] || {};
+  const target = String(wanted || "latest").trim() || "latest";
+
+  if (target === "latest") {
+    return distTags.latest || versions[0] || null;
+  }
+
+  if (distTags[target]) {
+    return distTags[target];
+  }
+
+  if (meta.versions?.[target]) {
+    return target;
+  }
+
+  if (!semver.validRange(target)) {
+    return null;
+  }
+
+  return semver.maxSatisfying(versions, target, {
+    includePrerelease: rangeMentionsPrerelease(target),
+  });
+}
+
+async function resolveVersion(name, wanted, registryContext) {
+  const cacheKey = `${name}@${wanted || "latest"}`;
+  if (registryContext.resolvedCache.has(cacheKey)) {
+    return registryContext.resolvedCache.get(cacheKey);
+  }
+
+  const promise = (async () => {
+    const alias = parseAliasSpec(wanted);
+    if (alias) {
+      const aliasResolved = await resolveVersion(
+        alias.targetName,
+        alias.targetRange,
+        registryContext,
+      );
+      return {
+        requestedName: name,
+        requestedRange: wanted,
+        actualName: alias.targetName,
+        version: typeof aliasResolved === "string" ? aliasResolved : aliasResolved.version,
+      };
+    }
+
+    const meta = await getPackageMeta(name, registryContext);
+    const resolvedVersion = pickVersionFromMeta(meta, wanted);
+
+    if (!resolvedVersion) {
+      throw new Error(`Cannot resolve version: ${name}@${wanted || "latest"}`);
+    }
+
+    return resolvedVersion;
+  })();
+
+  registryContext.resolvedCache.set(cacheKey, promise);
+  return promise;
+}
+
+function makeSkippedNode(name, requested, dependencyType, parent, reason) {
+  return {
+    name,
+    requested,
+    version: null,
+    dependencyType,
+    parent,
+    skipped: true,
+    reason,
+    dependencies: [],
+    peerDependencies: [],
+    bundledDependencies: [],
+    optionalDependencies: [],
+  };
+}
+
+async function buildNodeFromPackage(
+  pkgNameForMeta,
+  displayName,
+  wanted,
+  resolvedVersion,
+  edgeType,
+  parent,
+  registryContext,
+  visited,
+  extra = {},
+) {
+  const visitKey = `${pkgNameForMeta}@${resolvedVersion}`;
+
+  if (visited.has(visitKey)) {
+    return {
+      name: displayName,
+      requested: wanted || "latest",
+      version: resolvedVersion,
+      dependencyType: edgeType,
+      parent,
+      actualName: extra.actualName || null,
+      aliased: !!extra.aliased,
+      circularOrShared: true,
+      dependencies: [],
+      peerDependencies: [],
+      bundledDependencies: [],
+      optionalDependencies: [],
+    };
+  }
+
+  visited.add(visitKey);
+
+  const meta = await getPackageMeta(pkgNameForMeta, registryContext);
+  const pkg = meta.versions?.[resolvedVersion];
+  if (!pkg) {
+    throw new Error(`Missing version metadata: ${pkgNameForMeta}@${resolvedVersion}`);
+  }
+
+  const deps = pkg.dependencies || {};
+  const peerDeps = pkg.peerDependencies || {};
+  const optionalDeps = pkg.optionalDependencies || {};
+  const bundledList = Array.isArray(pkg.bundleDependencies)
+    ? pkg.bundleDependencies
+    : Array.isArray(pkg.bundledDependencies)
+      ? pkg.bundledDependencies
+      : [];
+
+  const parentRef = `${displayName}@${resolvedVersion}`;
+  const walk = (childName, childRange, dependencyType) =>
+    walkNode(childName, childRange, dependencyType, parentRef, registryContext, visited);
+
+  const depNodes = await Promise.all(
+    Object.entries(deps).map(([childName, childRange]) =>
+      walk(childName, childRange, "dependency"),
+    ),
+  );
+
+  const peerNodes = await Promise.all(
+    Object.entries(peerDeps).map(([childName, childRange]) =>
+      walk(childName, childRange, "peerDependency"),
+    ),
+  );
+
+  const optionalNodes = await Promise.all(
+    Object.entries(optionalDeps).map(([childName, childRange]) =>
+      walk(childName, childRange, "optionalDependency"),
+    ),
+  );
+
+  const bundledNodes = await Promise.all(
+    bundledList.map((childName) => {
+      const childRange = deps[childName] || optionalDeps[childName] || "latest";
+      return walk(childName, childRange, "bundledDependency");
+    }),
+  );
+
+  return {
+    name: displayName,
+    requested: wanted || "latest",
+    version: resolvedVersion,
+    actualName: extra.actualName || null,
+    aliased: !!extra.aliased,
+    description: pkg.description || "",
+    dependencyType: edgeType,
+    parent,
+    dependencies: depNodes,
+    peerDependencies: peerNodes,
+    bundledDependencies: bundledNodes,
+    optionalDependencies: optionalNodes,
+  };
+}
+
+async function walkNode(name, wanted, edgeType, parent, registryContext, visited) {
+  if (edgeType !== "root" && isNonRegistrySpec(wanted)) {
+    return makeSkippedNode(name, wanted, edgeType, parent, "non-registry spec");
+  }
+
+  const alias = parseAliasSpec(wanted);
+  if (alias) {
+    const resolvedAlias = await resolveVersion(name, wanted, registryContext);
+    return buildNodeFromPackage(
+      resolvedAlias.actualName,
+      name,
+      wanted,
+      resolvedAlias.version,
+      edgeType,
+      parent,
+      registryContext,
+      visited,
+      {
+        actualName: resolvedAlias.actualName,
+        aliased: true,
+      },
+    );
+  }
+
+  const resolvedVersion = await resolveVersion(name, wanted, registryContext);
+  return buildNodeFromPackage(
+    name,
+    name,
+    wanted,
+    resolvedVersion,
+    edgeType,
+    parent,
+    registryContext,
+    visited,
+  );
+}
+
+function flattenTree(tree) {
+  const out = [];
+  const seen = new Set();
+
+  function visit(node) {
+    const key = [
+      node.name,
+      node.actualName || "",
+      node.version || "null",
+      node.dependencyType,
+      node.parent || "root",
+      node.requested || "",
+    ].join("::");
+
+    if (seen.has(key)) return;
+    seen.add(key);
+
+    out.push({
+      name: node.name,
+      actualName: node.actualName || null,
+      requested: node.requested,
+      version: node.version,
+      dependencyType: node.dependencyType,
+      parent: node.parent,
+      description: node.description || "",
+      circularOrShared: !!node.circularOrShared,
+      skipped: !!node.skipped,
+      reason: node.reason || null,
+      aliased: !!node.aliased,
+    });
+
+    for (const child of node.dependencies || []) visit(child);
+    for (const child of node.peerDependencies || []) visit(child);
+    for (const child of node.bundledDependencies || []) visit(child);
+    for (const child of node.optionalDependencies || []) visit(child);
+  }
+
+  visit(tree);
+  return out;
+}
+
+async function collectNpmDeps(rootName, rootVersion = "latest", options = {}) {
+  const registryContext = options.registryContext || createRegistryContext(options.concurrency);
+  const visited = new Set();
+  const tree = await walkNode(rootName, rootVersion, "root", null, registryContext, visited);
+  const flat = flattenTree(tree);
+
+  return {
+    root: `${tree.name}@${tree.version}`,
+    tree,
+    flat,
+    options: { concurrency: registryContext.concurrency },
+  };
+}
+
+function sortObject(input) {
+  return Object.fromEntries(Object.entries(input).sort(([a], [b]) => a.localeCompare(b)));
+}
+
+function dedupe(items) {
+  return [...new Set(items.filter(Boolean))];
+}
+
+function getLibcollectConfig(pkg) {
+  const raw = pkg.libcollect && typeof pkg.libcollect === "object" ? pkg.libcollect : {};
+
+  const sourceSections =
+    Array.isArray(raw.sourceSections) && raw.sourceSections.length > 0
+      ? dedupe(raw.sourceSections)
+      : DEFAULT_SOURCE_SECTIONS;
+
+  const includeDependencyTypes =
+    Array.isArray(raw.includeDependencyTypes) && raw.includeDependencyTypes.length > 0
+      ? dedupe(raw.includeDependencyTypes)
+      : DEFAULT_INCLUDE_TYPES;
+
+  const autoIncludedDependencies = Array.isArray(raw.autoIncludedDependencies)
+    ? dedupe(raw.autoIncludedDependencies)
+    : [];
+
+  const autoIncludedDependencySpecs =
+    raw.autoIncludedDependencySpecs && typeof raw.autoIncludedDependencySpecs === "object"
+      ? { ...raw.autoIncludedDependencySpecs }
+      : {};
+
+  const concurrency =
+    Number.isFinite(raw.concurrency) && raw.concurrency > 0
+      ? Math.floor(raw.concurrency)
+      : DEFAULT_CONCURRENCY;
+
+  return {
+    sourceSections,
+    includeDependencyTypes,
+    autoIncludedDependencies,
+    autoIncludedDependencySpecs,
+    concurrency,
+    exactVersions: raw.exactVersions !== false,
+  };
+}
+
+function buildSourceRoots(pkg, config) {
+  const previousAuto = new Set(config.autoIncludedDependencies || []);
+  const previousAutoSpecs = config.autoIncludedDependencySpecs || {};
+  const currentDependencies = { ...pkg.dependencies };
+
+  const manualDependencies = Object.fromEntries(
+    Object.entries(currentDependencies).filter(([name, spec]) => {
+      if (!previousAuto.has(name)) return true;
+      return previousAutoSpecs[name] !== spec;
+    }),
+  );
+
+  const roots = [];
+  const seen = new Set();
+
+  for (const section of config.sourceSections) {
+    const sourceMap = section === "dependencies" ? manualDependencies : { ...pkg[section] };
+
+    for (const [name, range] of Object.entries(sourceMap)) {
+      if (seen.has(name)) continue;
+      seen.add(name);
+      roots.push({ name, range, sourceSection: section });
+    }
+  }
+
+  return { roots, manualDependencies };
+}
+
+function ensureCandidate(candidates, name) {
+  if (!candidates.has(name)) {
+    candidates.set(name, {
+      name,
+      actualName: null,
+      requestedRanges: new Set(),
+      resolvedVersions: new Set(),
+      dependencyTypes: new Set(),
+      parents: new Set(),
+      sourceSections: new Set(),
+      aliased: false,
+      versionConflict: null,
+    });
+  }
+
+  return candidates.get(name);
+}
+
+function addCandidate(candidates, node, extra = {}) {
+  const candidate = ensureCandidate(candidates, node.name);
+
+  if (node.actualName) candidate.actualName = node.actualName;
+  if (extra.actualName) candidate.actualName = extra.actualName;
+  if (node.requested) candidate.requestedRanges.add(node.requested);
+  if (extra.requestedRange) candidate.requestedRanges.add(extra.requestedRange);
+  if (node.version) candidate.resolvedVersions.add(node.version);
+  if (extra.resolvedVersion) candidate.resolvedVersions.add(extra.resolvedVersion);
+  if (node.dependencyType) candidate.dependencyTypes.add(node.dependencyType);
+  if (extra.dependencyType) candidate.dependencyTypes.add(extra.dependencyType);
+  if (node.parent) candidate.parents.add(node.parent);
+  if (extra.parent) candidate.parents.add(extra.parent);
+  if (extra.sourceSection) candidate.sourceSections.add(extra.sourceSection);
+  if (node.aliased || extra.aliased) candidate.aliased = true;
+}
+
+async function collectCandidates(pkg, config, registryContext) {
+  const { roots, manualDependencies } = buildSourceRoots(pkg, config);
+  const candidates = new Map();
+  const warnings = [];
+  const includeTypeSet = new Set(config.includeDependencyTypes);
+
+  for (const root of roots) {
+    if (root.sourceSection !== "dependencies") {
+      if (isNonRegistrySpec(root.range)) {
+        warnings.push(
+          `${root.name}: ${root.sourceSection}에 있는 non-registry spec(${root.range})은 dependencies로 자동 승격하지 않았습니다.`,
+        );
+      } else {
+        const resolvedRoot = await resolveVersion(root.name, root.range, registryContext);
+        addCandidate(
+          candidates,
+          {
+            name: root.name,
+            requested: root.range,
+            version: typeof resolvedRoot === "string" ? resolvedRoot : resolvedRoot.version,
+            actualName: typeof resolvedRoot === "string" ? null : resolvedRoot.actualName || null,
+            dependencyType: "sourceSection",
+          },
+          {
+            sourceSection: root.sourceSection,
+            aliased: !!(typeof resolvedRoot !== "string" && resolvedRoot.actualName),
+          },
+        );
+      }
+    }
+
+    if (isNonRegistrySpec(root.range)) {
+      warnings.push(
+        `${root.name}: root spec(${root.range})는 registry 기반이 아니어서 하위 dep 탐색을 건너뛰었습니다.`,
+      );
+      continue;
+    }
+
+    const result = await collectNpmDeps(root.name, root.range, {
+      registryContext,
+      concurrency: config.concurrency,
+    });
+
+    for (const node of result.flat) {
+      if (node.skipped) {
+        warnings.push(
+          `${node.name}: ${node.parent || "root"}에서 ${node.reason || "skipped"} 되어 자동 포함 대상에서 제외했습니다.`,
+        );
+        continue;
+      }
+
+      if (!includeTypeSet.has(node.dependencyType)) {
+        continue;
+      }
+
+      addCandidate(candidates, node);
+    }
+  }
+
+  return { candidates, warnings, manualDependencies, roots };
+}
+
+async function resolvePreferredSpec(name, candidate, pkg, config, registryContext) {
+  if (pkg.optionalDependencies?.[name]) return pkg.optionalDependencies[name];
+  if (pkg.peerDependencies?.[name]) return pkg.peerDependencies[name];
+
+  const ranges = [...candidate.requestedRanges].filter(Boolean);
+  const aliasRanges = ranges.map(parseAliasSpec).filter(Boolean);
+  const targetName = candidate.actualName || aliasRanges[0]?.targetName || name;
+  const normalizedRanges = ranges.map((range) => parseAliasSpec(range)?.targetRange || range);
+
+  const meta = await getPackageMeta(targetName, registryContext);
+  const versions = getAllVersions(meta);
+  const includePrerelease = normalizedRanges.some(rangeMentionsPrerelease);
+
+  const commonVersion = versions.find((version) =>
+    normalizedRanges.every((range) => {
+      if (range === "latest" || range === "*") return true;
+      if (meta.versions?.[range]) return version === range;
+      if (!semver.validRange(range)) return false;
+      return semver.satisfies(version, range, { includePrerelease });
+    }),
+  );
+
+  const fallbackVersion =
+    commonVersion ||
+    [...candidate.resolvedVersions].filter((v) => !!semver.valid(v)).sort(semver.rcompare)[0];
+
+  if (!fallbackVersion) {
+    throw new Error(`자동 포함 버전을 결정할 수 없습니다: ${name}`);
+  }
+
+  if (!commonVersion && normalizedRanges.length > 1) {
+    candidate.versionConflict = {
+      targetName,
+      ranges: normalizedRanges,
+      picked: fallbackVersion,
+    };
+  }
+
+  if (candidate.actualName || aliasRanges.length > 0) {
+    return `npm:${targetName}@${fallbackVersion}`;
+  }
+
+  return config.exactVersions ? fallbackVersion : `^${fallbackVersion}`;
+}
+
+function diffKeys(beforeObj, afterObj) {
+  const before = new Set(Object.keys(beforeObj || {}));
+  const after = new Set(Object.keys(afterObj || {}));
+
+  return {
+    added: [...after].filter((name) => !before.has(name)).sort(),
+    removed: [...before].filter((name) => !after.has(name)).sort(),
+  };
+}
+
+export async function includeDependencies(
+  packageJsonPath = path.resolve(process.cwd(), "package.json"),
+) {
+  const rawText = await fs.readFile(packageJsonPath, "utf8");
+  const pkg = JSON.parse(rawText);
+  const config = getLibcollectConfig(pkg);
+  const registryContext = createRegistryContext(config.concurrency);
+  const beforeDependencies = { ...pkg.dependencies };
+
+  const { candidates, warnings, manualDependencies, roots } = await collectCandidates(
+    pkg,
+    config,
+    registryContext,
+  );
+
+  const autoIncludedDependencies = {};
+  const versionConflictWarnings = [];
+
+  for (const [name, candidate] of [...candidates.entries()].sort(([a], [b]) =>
+    a.localeCompare(b),
+  )) {
+    if (manualDependencies[name]) {
+      continue;
+    }
+
+    const spec = await resolvePreferredSpec(name, candidate, pkg, config, registryContext);
+    autoIncludedDependencies[name] = spec;
+
+    if (candidate.versionConflict) {
+      versionConflictWarnings.push(
+        `${name}: ${candidate.versionConflict.ranges.join(" , ")} 를 동시에 만족하는 공통 버전을 찾지 못해 ${candidate.versionConflict.picked} 로 고정했습니다.`,
+      );
+    }
+  }
+
+  const nextDependencies = sortObject({
+    ...manualDependencies,
+    ...autoIncludedDependencies,
+  });
+
+  pkg.dependencies = nextDependencies;
+  pkg.libcollect = {
+    ...(pkg.libcollect && typeof pkg.libcollect === "object" ? pkg.libcollect : {}),
+    sourceSections: config.sourceSections,
+    includeDependencyTypes: config.includeDependencyTypes,
+    autoIncludedDependencies: Object.keys(autoIncludedDependencies).sort(),
+    autoIncludedDependencySpecs: sortObject(autoIncludedDependencies),
+    concurrency: config.concurrency,
+    exactVersions: config.exactVersions,
+  };
+
+  await fs.writeFile(`${packageJsonPath}.bak`, rawText, "utf8");
+  await fs.writeFile(packageJsonPath, `${JSON.stringify(pkg, null, 2)}\n`, "utf8");
+
+  const { added, removed } = diffKeys(beforeDependencies, nextDependencies);
+
+  return {
+    packageJsonPath,
+    backupPath: `${packageJsonPath}.bak`,
+    roots,
+    added,
+    removed,
+    warnings: [...warnings, ...versionConflictWarnings],
+    autoIncludedCount: Object.keys(autoIncludedDependencies).length,
+    dependencyCount: Object.keys(nextDependencies).length,
+  };
+}
+
+function parseCliArgs(argv) {
+  const args = argv.slice(2);
+  const command = args[0] && !args[0].startsWith("-") ? args[0] : "include";
+  const flags = new Map();
+
+  for (const arg of args.slice(command === "include" ? 1 : 0)) {
+    if (!arg.startsWith("--")) continue;
+    const [key, value] = arg.slice(2).split("=");
+    flags.set(key, value ?? "true");
+  }
+
+  return { command, flags };
+}
+
+async function runCli() {
+  const { command } = parseCliArgs(process.argv);
+
+  if (command !== "include") {
+    console.error(`Unknown command: ${command}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  try {
+    const result = await includeDependencies();
+    console.log(
+      `[libcollect] roots: ${result.roots.map((x) => `${x.name}@${x.range}`).join(", ")}`,
+    );
+    console.log(
+      `[libcollect] dependencies: ${result.dependencyCount} total, ${result.autoIncludedCount} auto-included`,
+    );
+    console.log(`[libcollect] added: ${result.added.length}, removed: ${result.removed.length}`);
+    console.log(`[libcollect] backup: ${result.backupPath}`);
+
+    if (result.added.length > 0) {
+      console.log(`[libcollect] added deps: ${result.added.join(", ")}`);
+    }
+
+    if (result.removed.length > 0) {
+      console.log(`[libcollect] removed deps: ${result.removed.join(", ")}`);
+    }
+
+    if (result.warnings.length > 0) {
+      console.warn("[libcollect] warnings:");
+      for (const warning of result.warnings) {
+        console.warn(`  - ${warning}`);
+      }
+    }
+  } catch (error) {
+    console.error(`[libcollect] failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+  }
+}
+
+const currentModulePath = fileURLToPath(import.meta.url);
+const invokedPath = process.argv[1] ? path.resolve(process.argv[1]) : null;
+
+if (invokedPath && currentModulePath === invokedPath) {
+  await runCli();
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@seorii/libcollect",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "libcollect": "./include-deps.mjs"
+  },
+  "scripts": {
+    "include": "node ./include-deps.mjs include",
+    "prepublishOnly": "npm run include"
+  },
+  "libcollect": {
+    "sourceSections": [
+      "dependencies",
+      "optionalDependencies",
+      "peerDependencies"
+    ],
+    "includeDependencyTypes": [
+      "peerDependency",
+      "optionalDependency",
+      "bundledDependency"
+    ],
+    "concurrency": 10,
+    "exactVersions": true,
+    "autoIncludedDependencies": [],
+    "autoIncludedDependencySpecs": {}
+  },
+  "dependencies": {
+    "semver": "^7.7.4"
+  }
+}