@blzsky/variant 0.2.1 → 0.3.0-canary.0

package/dist/chunk-SGP5JX6I.js

@@ -0,0 +1,377 @@
+import {
+  loadPackageGraph
+} from "./chunk-3E5LBU3O.js";
+import {
+  defaultBranchRef
+} from "./chunk-RSIOYQOQ.js";
+
+// src/core/setup/discover.ts
+import { access, readFile } from "fs/promises";
+import path from "path";
+
+// src/core/setup/workflow.ts
+var TEST_COMMAND = /\b(?:vitest|jest)\b|\b(?:npm|pnpm|yarn|bun)(?:\s+run)?\s+test\b|\bturbo(?:\s+run)?\s+test\b|\bnx\s+(?:run-many|affected|test)\b/;
+function runsTests(workflow) {
+  return workflow.split("\n").some((line) => !line.trim().startsWith("#") && TEST_COMMAND.test(line));
+}
+var CHECKOUT = /^(\s*)(-\s+)?uses:\s*actions\/checkout@\S+\s*$/;
+function indentOf(line) {
+  return line.length - line.trimStart().length;
+}
+function withFullHistory(workflow) {
+  const lines = workflow.split("\n");
+  const out = [];
+  let changed = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    out.push(line);
+    const match = CHECKOUT.exec(line);
+    if (match === null) continue;
+    const keyIndent = (match[1]?.length ?? 0) + (match[2]?.length ?? 0);
+    const pad = " ".repeat(keyIndent);
+    let end = i + 1;
+    while (end < lines.length) {
+      const next = lines[end] ?? "";
+      if (next.trim() !== "" && indentOf(next) < keyIndent) break;
+      if (next.trim().startsWith("- ") && indentOf(next) < keyIndent) break;
+      end++;
+    }
+    const step = lines.slice(i + 1, end);
+    const withAt = step.findIndex(
+      (l) => indentOf(l) === keyIndent && /^with:\s*$/.test(l.trim())
+    );
+    if (withAt === -1) {
+      out.push(`${pad}with:`, `${pad}  fetch-depth: 0`);
+      changed = true;
+      continue;
+    }
+    const depthAt = step.findIndex(
+      (l, index) => index > withAt && indentOf(l) > keyIndent && /^fetch-depth:/.test(l.trim())
+    );
+    for (let j = 0; j < step.length; j++) {
+      const stepLine = step[j] ?? "";
+      if (j === depthAt) {
+        const fixed = stepLine.replace(/fetch-depth:.*$/, "fetch-depth: 0");
+        if (fixed !== stepLine) changed = true;
+        out.push(fixed);
+        continue;
+      }
+      out.push(stepLine);
+      if (j === withAt && depthAt === -1) {
+        out.push(`${pad}  fetch-depth: 0`);
+        changed = true;
+      }
+    }
+    i = end - 1;
+  }
+  return changed ? out.join("\n") : null;
+}
+var ACTIONS = [
+  "actions/checkout",
+  "actions/setup-node",
+  "actions/github-script",
+  "pnpm/action-setup",
+  "oven-sh/setup-bun"
+];
+function workflowStyle(workflow) {
+  const actions = {};
+  let node;
+  let bun;
+  for (const raw of workflow.split("\n")) {
+    const line = raw.trim();
+    if (line.startsWith("#")) continue;
+    const uses = /^(?:-\s+)?uses:\s*(\S+)@(\S+)/.exec(line);
+    if (uses !== null) {
+      const [, action, version] = uses;
+      if (action !== void 0 && ACTIONS.includes(action)) {
+        actions[action] ??= `${action}@${version}`;
+      }
+      continue;
+    }
+    if (line.includes("${{")) continue;
+    if (/^node-version(?:-file)?:\s*\S/.test(line)) node ??= line;
+    if (/^bun-version(?:-file)?:\s*\S/.test(line)) bun ??= line;
+  }
+  return {
+    actions,
+    ...node !== void 0 && { node },
+    ...bun !== void 0 && { bun }
+  };
+}
+var DEFAULT_ACTIONS = {
+  "actions/checkout": "actions/checkout@v7",
+  "actions/setup-node": "actions/setup-node@v7",
+  "actions/github-script": "actions/github-script@v9",
+  "pnpm/action-setup": "pnpm/action-setup@v4",
+  "oven-sh/setup-bun": "oven-sh/setup-bun@v2"
+};
+var INSTALL = {
+  npm: "npm ci",
+  pnpm: "pnpm install --frozen-lockfile",
+  yarn: "yarn install --frozen-lockfile",
+  bun: "bun install --frozen-lockfile"
+};
+var EXEC = {
+  npm: "npx --no -- variant",
+  pnpm: "pnpm exec variant",
+  yarn: "yarn variant",
+  bun: "bun run variant"
+};
+var NODE_CACHE = {
+  npm: "npm",
+  pnpm: "pnpm",
+  yarn: "yarn"
+};
+function pullRequestWorkflow(packageManager, style = { actions: {} }) {
+  const cache = NODE_CACHE[packageManager];
+  const action = (name) => style.actions[name] ?? DEFAULT_ACTIONS[name] ?? name;
+  const setup = packageManager === "pnpm" ? [`      - uses: ${action("pnpm/action-setup")}`, ""] : packageManager === "bun" ? [
+    `      - uses: ${action("oven-sh/setup-bun")}`,
+    ...style.bun === void 0 ? [] : ["        with:", `          ${style.bun}`],
+    ""
+  ] : [];
+  return [
+    "# Written by `variant init`. It keeps one comment on each pull request",
+    "# saying what the change affects. It is yours to edit.",
+    "",
+    "name: variant",
+    "",
+    "on:",
+    "  pull_request:",
+    "",
+    "permissions:",
+    "  contents: read",
+    "  pull-requests: write",
+    "",
+    "# A newer push makes the report for an older one pointless.",
+    "concurrency:",
+    // Split so the linter does not take a workflow expression for a
+    // template placeholder someone forgot the backticks on.
+    `  group: variant-$${"{{ github.event.pull_request.number }}"}`,
+    "  cancel-in-progress: true",
+    "",
+    "jobs:",
+    "  report:",
+    "    runs-on: ubuntu-latest",
+    "    timeout-minutes: 10",
+    "    steps:",
+    `      - uses: ${action("actions/checkout")}`,
+    "        with:",
+    "          # variant compares against the commit the branch started from.",
+    "          fetch-depth: 0",
+    "",
+    ...setup,
+    `      - uses: ${action("actions/setup-node")}`,
+    "        with:",
+    `          ${style.node ?? "node-version: 22"}`,
+    ...cache === void 0 ? [] : [`          cache: ${cache}`],
+    "",
+    `      - run: ${INSTALL[packageManager]}`,
+    "",
+    "      - name: Describe the pull request",
+    `        run: ${EXEC[packageManager]} pr report --markdown --output pr-report.md`,
+    "",
+    "      - name: Post or update the comment",
+    "        # Pull requests from forks get a read-only token and cannot comment.",
+    "        if: github.event.pull_request.head.repo.full_name == github.repository",
+    `        uses: ${action("actions/github-script")}`,
+    "        with:",
+    "          script: |",
+    '            const fs = require("node:fs");',
+    '            const body = fs.readFileSync("pr-report.md", "utf8");',
+    "            // The first line of every report; it marks the comment to update.",
+    '            const marker = "## Variant PR Report";',
+    "            const { owner, repo } = context.repo;",
+    "            const issue_number = context.issue.number;",
+    "            const comments = await github.paginate(github.rest.issues.listComments, {",
+    "              owner,",
+    "              repo,",
+    "              issue_number,",
+    "            });",
+    "            const existing = comments.find(",
+    "              (comment) =>",
+    '                comment.user?.login === "github-actions[bot]" &&',
+    "                comment.body?.startsWith(marker),",
+    "            );",
+    "            if (existing) {",
+    "              await github.rest.issues.updateComment({ owner, repo, comment_id: existing.id, body });",
+    "            } else {",
+    "              await github.rest.issues.createComment({ owner, repo, issue_number, body });",
+    "            }",
+    ""
+  ].join("\n");
+}
+
+// src/core/setup/discover.ts
+var LOCKFILES = [
+  ["bun.lock", "bun"],
+  ["bun.lockb", "bun"],
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["package-lock.json", "npm"],
+  ["npm-shrinkwrap.json", "npm"]
+];
+var IGNORE = ["**/node_modules/**", "**/dist/**", ".git/**", ".variant/**"];
+async function readText(file) {
+  try {
+    return await readFile(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function readManifest(cwd) {
+  const raw = await readText(path.join(cwd, "package.json"));
+  if (raw === null) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+var MANAGERS = /* @__PURE__ */ new Set(["npm", "pnpm", "yarn", "bun"]);
+async function managerIn(dir) {
+  for (const [lockfile, name2] of LOCKFILES) {
+    if (await readText(path.join(dir, lockfile)) !== null) return name2;
+  }
+  const declared = (await readManifest(dir))?.packageManager;
+  const name = typeof declared === "string" ? declared.split("@")[0] : void 0;
+  return name !== void 0 && MANAGERS.has(name) ? name : null;
+}
+async function detectPackageManager(cwd) {
+  let dir = path.resolve(cwd);
+  for (; ; ) {
+    const found = await managerIn(dir);
+    if (found !== null) return found;
+    const parent = path.dirname(dir);
+    const atRoot = await access(path.join(dir, ".git")).then(
+      () => true,
+      () => false
+    );
+    if (parent === dir || atRoot) return null;
+    dir = parent;
+  }
+}
+async function packageManagerOf(cwd) {
+  return detectPackageManager(cwd);
+}
+var CONFIG_FLAG = /(?:--config|-c)(?:=|\s+)(\S+)/;
+function vitestRuns(manifest) {
+  const configs = [];
+  let plain = false;
+  for (const script of Object.values(manifest?.scripts ?? {})) {
+    if (typeof script !== "string") continue;
+    for (const command of script.split(/&&|\|\||;/)) {
+      if (!/\bvitest\b/.test(command)) continue;
+      const config = CONFIG_FLAG.exec(command)?.[1];
+      if (config === void 0) plain = true;
+      else configs.push(config.replace(/^["']|["']$/g, ""));
+    }
+  }
+  return { plain, configs };
+}
+function adapterTargets(configs, packageDirs) {
+  const root = configs.filter((file) => !file.includes("/"));
+  if (root.length > 0) return root;
+  const dirs = new Set(packageDirs);
+  return configs.filter((file) => dirs.has(path.posix.dirname(file)));
+}
+async function discoverRepository(cwd) {
+  const fg = (await import("fast-glob")).default;
+  const [manifest, packageGraph, found, gitignore, branch] = await Promise.all([
+    readManifest(cwd),
+    loadPackageGraph(cwd).catch(() => null),
+    fg(
+      [
+        "**/vitest.config.{ts,mts,cts,js,mjs,cjs}",
+        "**/vite.config.{ts,mts,cts,js,mjs,cjs}",
+        "**/jest.config.{ts,mts,cts,js,mjs,cjs,json}",
+        "**/playwright.config.{ts,mts,cts,js,mjs,cjs}",
+        ".github/workflows/*.{yml,yaml}",
+        "turbo.json",
+        "nx.json"
+      ],
+      { cwd, onlyFiles: true, dot: true, ignore: IGNORE }
+    ),
+    readText(path.join(cwd, ".gitignore")),
+    defaultBranchRef(cwd)
+  ]);
+  const files = found.map((file) => file.replace(/\\/g, "/")).sort();
+  const named = (prefix) => files.filter((file) => path.posix.basename(file).startsWith(prefix));
+  const packageDirs = (packageGraph?.packages ?? []).map(
+    (pkg) => path.relative(cwd, pkg.dir).replace(/\\/g, "/")
+  );
+  const workflows = await Promise.all(
+    files.filter((file) => file.startsWith(".github/workflows/")).map(async (file) => {
+      const content = await readText(path.join(cwd, file)) ?? "";
+      return {
+        file,
+        content,
+        runsTests: runsTests(content),
+        shallow: withFullHistory(content) !== null
+      };
+    })
+  );
+  const vitestConfigs = adapterTargets(named("vitest.config."), packageDirs);
+  const hasRootConfig = vitestConfigs.some((file) => !file.includes("/"));
+  const configDirs = (prefix) => new Map(
+    named(prefix).map((file) => {
+      const dir = path.posix.dirname(file);
+      return [dir === "." ? "" : dir, file];
+    })
+  );
+  const vitestDirs = configDirs("vitest.config.");
+  const viteDirs = configDirs("vite.config.");
+  const members = (packageGraph?.packages ?? []).map((pkg) => ({
+    dir: path.relative(cwd, pkg.dir).replace(/\\/g, "/"),
+    manifest: pkg.manifest
+  })).filter((member) => member.dir !== "");
+  const usesVitest = (candidate) => "vitest" in (candidate?.devDependencies ?? {}) || "vitest" in (candidate?.dependencies ?? {});
+  const everyone = [{ dir: "", manifest }, ...members];
+  const runs = new Map(
+    everyone.map((member) => [member.dir, vitestRuns(member.manifest)])
+  );
+  const scripted = everyone.some((member) => {
+    const run = runs.get(member.dir);
+    return run !== void 0 && (run.plain || run.configs.length > 0);
+  });
+  const users = members.filter((member) => usesVitest(member.manifest));
+  const runners = scripted ? everyone.filter((member) => runs.get(member.dir)?.plain === true) : users.length > 0 ? users : usesVitest(manifest) ? [{ dir: "", manifest }] : [];
+  const unconfigured = hasRootConfig ? [] : runners.filter((runner) => !vitestDirs.has(runner.dir));
+  const scriptConfigs = everyone.flatMap(
+    (member) => (runs.get(member.dir)?.configs ?? []).map(
+      (config) => path.posix.normalize(path.posix.join(member.dir, config))
+    )
+  );
+  const allConfigs = [.../* @__PURE__ */ new Set([...vitestConfigs, ...scriptConfigs])].sort();
+  return {
+    packageManager: await detectPackageManager(cwd),
+    workspacePackages: packageDirs.filter((dir) => dir !== "").length,
+    taskRunner: files.includes("turbo.json") ? "turborepo" : files.includes("nx.json") ? "nx" : null,
+    vitestConfigs: allConfigs,
+    vitestWithoutConfig: unconfigured.filter((runner) => !viteDirs.has(runner.dir)).map((runner) => runner.dir).sort(),
+    viteConfigs: unconfigured.flatMap((runner) => viteDirs.get(runner.dir) ?? []).sort(),
+    reporterFlags: [{ dir: "", manifest }, ...members].filter(
+      (member) => Object.values(member.manifest?.scripts ?? {}).some(
+        (script) => typeof script === "string" && /\bvitest\b.*--reporter\b/.test(script)
+      )
+    ).map(
+      (member) => member.dir === "" ? "package.json" : `${member.dir}/package.json`
+    ).sort(),
+    jestConfigs: named("jest.config."),
+    playwrightConfigs: named("playwright.config."),
+    workflows,
+    defaultBranch: branch?.replace(/^origin\//, "") ?? null,
+    installed: "@blzsky/variant" in (manifest?.devDependencies ?? {}) || "@blzsky/variant" in (manifest?.dependencies ?? {}),
+    ignoresVariantDir: (gitignore ?? "").split("\n").some((line) => /^\/?\.variant\/?$/.test(line.trim())),
+    hasManifest: manifest !== null
+  };
+}
+
+export {
+  withFullHistory,
+  workflowStyle,
+  pullRequestWorkflow,
+  packageManagerOf,
+  discoverRepository
+};

package/dist/chunk-X3VVGTEV.js

@@ -0,0 +1,268 @@
+// src/core/graph/tsconfig-paths.ts
+import { readFile } from "fs/promises";
+import path3 from "path";
+
+// src/core/graph/package-imports.ts
+import path2 from "path";
+
+// src/core/graph/package-exports.ts
+import path from "path";
+var BUILD_DIRS = ["dist", "lib", "build", "out", "es", "esm", "cjs"];
+var SOURCE_DIRS = ["src", "lib", "source", ""];
+var CONDITIONS = [
+  "source",
+  "development",
+  "import",
+  "module",
+  "require",
+  "types",
+  "node",
+  "default"
+];
+var MAX_CONDITION_DEPTH = 8;
+function conditionTargets(value) {
+  return targetsOf(value);
+}
+function targetsOf(value, depth = 0) {
+  if (depth > MAX_CONDITION_DEPTH) return [];
+  if (typeof value === "string") return [value];
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => targetsOf(entry, depth + 1));
+  }
+  if (typeof value !== "object" || value === null) return [];
+  const record = value;
+  const out = [];
+  for (const condition of CONDITIONS) {
+    if (condition in record) {
+      out.push(...targetsOf(record[condition], depth + 1));
+    }
+  }
+  for (const [key, nested] of Object.entries(record)) {
+    if (!CONDITIONS.includes(key) && !key.startsWith(".")) {
+      out.push(...targetsOf(nested, depth + 1));
+    }
+  }
+  return out;
+}
+function clean(target) {
+  if (!target.startsWith("./")) return void 0;
+  return target.slice(2);
+}
+function resolveExportsSubpath(exportsField, subpath) {
+  if (exportsField === void 0 || exportsField === null) return [];
+  const request = subpath === "" ? "." : `./${subpath}`;
+  const isSubpathMap = typeof exportsField === "object" && !Array.isArray(exportsField) && Object.keys(exportsField).some(
+    (k) => k.startsWith(".")
+  );
+  if (!isSubpathMap) {
+    return request === "." ? targetsOf(exportsField).map(clean).filter((t) => t !== void 0) : [];
+  }
+  const map = exportsField;
+  if (request in map) {
+    return targetsOf(map[request]).map(clean).filter((t) => t !== void 0);
+  }
+  const patterns = Object.keys(map).filter((key) => key.startsWith("./") && key.includes("*")).sort((a, b) => b.length - a.length);
+  for (const pattern of patterns) {
+    const [prefix = "", suffix = ""] = pattern.split("*");
+    if (request.length < prefix.length + suffix.length || !request.startsWith(prefix) || !request.endsWith(suffix)) {
+      continue;
+    }
+    const captured = request.slice(
+      prefix.length,
+      request.length - suffix.length
+    );
+    const targets = targetsOf(map[pattern]).map((t) => clean(t.replace("*", captured))).filter((t) => t !== void 0);
+    if (targets.length > 0) return targets;
+  }
+  return [];
+}
+function toSourceCandidates(target) {
+  const withoutExtension = stripExtension(target);
+  const segments = withoutExtension.split("/");
+  const head = segments[0];
+  const bodies = head !== void 0 && BUILD_DIRS.includes(head) && segments.length > 1 ? [segments.slice(1).join("/")] : [withoutExtension];
+  const out = [];
+  for (const body of bodies) {
+    for (const dir of SOURCE_DIRS) {
+      out.push(dir === "" ? body : `${dir}/${body}`);
+    }
+  }
+  return [...new Set(out)];
+}
+function stripExtension(target) {
+  if (target.endsWith(".d.ts")) return target.slice(0, -".d.ts".length);
+  const ext = path.posix.extname(target);
+  return ext === "" ? target : target.slice(0, -ext.length);
+}
+function exportsCandidates(exportsField, subpath) {
+  const targets = resolveExportsSubpath(exportsField, subpath);
+  if (targets.length === 0) return [];
+  const out = [];
+  for (const target of targets) out.push(stripExtension(target));
+  for (const target of targets) out.push(...toSourceCandidates(target));
+  return [...new Set(out)];
+}
+
+// src/core/graph/package-imports.ts
+function toImportAliases(dir, importsField) {
+  if (typeof importsField !== "object" || importsField === null || Array.isArray(importsField)) {
+    return [];
+  }
+  const aliases = [];
+  for (const [key, value] of Object.entries(importsField)) {
+    if (!key.startsWith("#")) continue;
+    const stars = key.split("*").length - 1;
+    if (stars > 1) continue;
+    const targets = conditionTargets(value).filter((target) => target.startsWith("./")).map((target) => path2.posix.join(dir, target));
+    if (targets.length === 0) continue;
+    const wildcard = stars === 1;
+    const [prefix = "", suffix = ""] = wildcard ? key.split("*") : [key, ""];
+    aliases.push({
+      prefix,
+      suffix,
+      wildcard,
+      targets,
+      ...dir !== "" && { scope: dir }
+    });
+  }
+  aliases.sort((a, b) => b.prefix.length - a.prefix.length);
+  return aliases;
+}
+
+// src/core/graph/tsconfig-paths.ts
+var MAX_WILDCARDS = 1;
+function toPathAliases(cwd, paths, baseUrl, scope) {
+  if (paths === void 0) return [];
+  const base = baseUrl ?? cwd;
+  const aliases = [];
+  for (const [pattern, rawTargets] of Object.entries(paths)) {
+    const stars = pattern.split("*").length - 1;
+    if (stars > MAX_WILDCARDS) continue;
+    const wildcard = stars === 1;
+    const [prefix = "", suffix = ""] = wildcard ? pattern.split("*") : [pattern, ""];
+    const targets = [];
+    for (const target of rawTargets) {
+      if (target.split("*").length - 1 > MAX_WILDCARDS) continue;
+      const absolute = path3.resolve(base, target);
+      const relative = path3.relative(cwd, absolute).replace(/\\/g, "/");
+      if (relative === "" || relative.startsWith("../")) continue;
+      targets.push(relative);
+    }
+    if (targets.length > 0) {
+      aliases.push({
+        prefix,
+        suffix,
+        wildcard,
+        targets,
+        ...scope !== void 0 && { scope }
+      });
+    }
+  }
+  aliases.sort((a, b) => b.prefix.length - a.prefix.length);
+  return aliases;
+}
+function matchPathAlias(spec, aliases) {
+  const bases = [];
+  for (const alias of aliases) {
+    if (!alias.wildcard) {
+      if (spec === alias.prefix) bases.push(...alias.targets);
+      continue;
+    }
+    if (spec.length < alias.prefix.length + alias.suffix.length || !spec.startsWith(alias.prefix) || !spec.endsWith(alias.suffix)) {
+      continue;
+    }
+    const captured = spec.slice(
+      alias.prefix.length,
+      spec.length - alias.suffix.length
+    );
+    for (const target of alias.targets) {
+      bases.push(target.replace("*", captured));
+    }
+  }
+  return bases;
+}
+function aliasesInScope(file, aliases) {
+  return aliases.filter(
+    (alias) => alias.scope === void 0 || file.startsWith(`${alias.scope}/`)
+  ).sort((a, b) => (b.scope?.length ?? -1) - (a.scope?.length ?? -1));
+}
+var CONFIG_IGNORE = [
+  "**/node_modules/**",
+  "**/dist/**",
+  ".git/**",
+  ".variant/**"
+];
+async function readPathAliases(cwd) {
+  const fg = (await import("fast-glob")).default;
+  const found = (await fg(["**/tsconfig.json", "**/package.json"], {
+    cwd,
+    onlyFiles: true,
+    ignore: CONFIG_IGNORE
+  })).map((file) => file.replace(/\\/g, "/")).sort();
+  const named = (name) => found.filter((file) => path3.posix.basename(file) === name);
+  const [fromTsconfig, fromManifests] = await Promise.all([
+    tsconfigAliases(cwd, named("tsconfig.json")),
+    Promise.all(
+      named("package.json").map((file) => manifestImportAliases(cwd, file))
+    )
+  ]);
+  return [...fromTsconfig, ...fromManifests.flat()];
+}
+async function manifestImportAliases(cwd, manifestPath) {
+  try {
+    const manifest = JSON.parse(
+      await readFile(path3.join(cwd, manifestPath), "utf8")
+    );
+    if (typeof manifest !== "object" || manifest === null) return [];
+    const dir = path3.posix.dirname(manifestPath);
+    return toImportAliases(
+      dir === "." ? "" : dir,
+      manifest.imports
+    );
+  } catch {
+    return [];
+  }
+}
+async function tsconfigAliases(cwd, configs) {
+  if (configs.length === 0) return [];
+  const { ts } = await import("ts-morph");
+  const aliases = [];
+  for (const config of configs) {
+    const configPath = path3.join(cwd, config);
+    const configDir = path3.dirname(configPath);
+    const read = ts.readConfigFile(configPath, (file) => ts.sys.readFile(file));
+    if (read.error !== void 0 || read.config === void 0) continue;
+    const { options } = ts.parseJsonConfigFileContent(
+      read.config,
+      {
+        ...ts.sys,
+        // Enumerating every file in the workspace is pure waste: only
+        // `compilerOptions` is wanted, and a large repo makes this the
+        // most expensive call in the command.
+        readDirectory: () => [],
+        useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames
+      },
+      configDir
+    );
+    const pathsBase = options["pathsBasePath"];
+    const base = options.baseUrl ?? (typeof pathsBase === "string" ? pathsBase : configDir);
+    const scope = path3.posix.dirname(config);
+    aliases.push(
+      ...toPathAliases(
+        cwd,
+        options.paths,
+        base,
+        scope === "." ? void 0 : scope
+      )
+    );
+  }
+  return aliases;
+}
+
+export {
+  exportsCandidates,
+  toPathAliases,
+  matchPathAlias,
+  aliasesInScope,
+  readPathAliases
+};

package/dist/{chunk-Q7RLUZSN.js → chunk-YII4TAKS.js}

@@ -1,16 +1,23 @@
 import {
   classifyChange
-} from "./chunk-FZEXZBXB.js";
+} from "./chunk-MAK3HG46.js";
 import {
   readFileAtRef
-} from "./chunk-6BXSZPHC.js";
+} from "./chunk-RSIOYQOQ.js";
+import {
+  CliUsageError
+} from "./chunk-ACTY42RE.js";
 
 // src/core/semantic/file-change.ts
 import { readFile } from "fs/promises";
 import path from "path";
 var DEFAULT_DIFF_BASE_REF = "HEAD~1";
 function toWorkspaceRelative(cwd, filePath) {
-  return path.relative(cwd, path.resolve(cwd, filePath)).replace(/\\/g, "/");
+  const relative = path.relative(cwd, path.resolve(cwd, filePath));
+  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    throw new CliUsageError(`${filePath} is outside the repository at ${cwd}`);
+  }
+  return relative.replace(/\\/g, "/");
 }
 async function classifyFileAgainstRef(cwd, relPath, baseRef) {
   const [before, after] = await Promise.all([