@bridge-ds/core 0.8.0 → 0.10.0

package/dist/node/git-local.d.ts

@@ -29,3 +29,18 @@ export declare function commitToNewLocalBranch(root: string, args: LocalCommitIn
     sha: string;
     diff: string;
 }>;
+/**
+ * A commit with `files` on top of `base`, built in a throwaway index and pointed to by no branch: nothing in the working
+ * tree, the index or the refs changes. commitToNewLocalBranch names it; a patch (git format-patch) can be read from it.
+ */
+export declare function commitTree(root: string, args: {
+    base: string;
+    message: string;
+    files: {
+        path: string;
+        content: string | null;
+    }[];
+}): Promise<{
+    sha: string;
+    parent: string;
+}>;

package/dist/node/index.d.ts

@@ -4,3 +4,4 @@ export * from './audit';
 export * from './component-specs';
 export * from './spec-css';
 export * from './spec-motion';
+export * from './suggestion-apply-node';

package/dist/node/index.js

@@ -1,11 +1,11 @@
 import { execFile } from "node:child_process";
-import { mkdtemp, rm } from "node:fs/promises";
+import { mkdtemp, rm, mkdir, writeFile, lstat, readFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve, relative, dirname, sep, posix } from "node:path";
-import { a as assertSafeBranch, c as collectHistory, p as packageDirCandidates, b as parseChangelog, m as mergeReleases, r as releasesFromTags, d as buildReport, e as prNumberFromSubject, l as loadConfig, s as specHash, v as validateComponentSpec, h as hashSpec, i as iconComponentName, f as variantKeyOf, C as CONFIG_FILE, g as layoutOptions, j as buildTokenSet, k as defaultContext, t as tokenCssVar, n as resolve$1, o as COMPONENT_SPECS_VERSION, q as COLOR_FIELDS } from "../component-spec-SKuywZqr.js";
-import { s as selectTokenFiles, g as globToRegExp, L as LayeredTokenSet } from "../layered-BnbmToGs.js";
+import { aT as assertSafeBranch, c as collectHistory, p as packageDirCandidates, a as parseChangelog, m as mergeReleases, r as releasesFromTags, b as buildReport, cq as prNumberFromSubject, cN as specHash, d9 as validateComponentSpec, bM as hashSpec, bN as iconComponentName, C as variantKeyOf, d5 as tokenCssVar, ai as COMPONENT_SPECS_VERSION, ah as COLOR_FIELDS, cQ as suggestionAppliedComment, X as gitBlobSha, co as planSuggestionApply } from "../suggestion-apply-ByBEYtct.js";
+import { K as selectTokenFiles, bl as globToRegExp, N as loadConfig, L as LayeredTokenSet, V as CONFIG_FILE, $ as layoutOptions, a0 as buildTokenSet, b3 as defaultContext, B as resolve$1, ae as slugify, bX as protectedBranchesOf, aM as baseBranchOf } from "../prod-branch-BdMPKffE.js";
 import { statSync, readFileSync, existsSync, writeFileSync, readdirSync } from "node:fs";
-import { v as isAuditable, Q as planCssFixes, O as parseAllowlist, c as DesignSystemIndex, k as buildAuditReport, n as compareWithBaseline, a as AUDIT_IGNORE_DIRS } from "../report-iPSnsjYi.js";
+import { i as isAuditable, Q as planCssFixes, O as parseAllowlist, d as DesignSystemIndex, l as buildAuditReport, o as compareWithBaseline, b as AUDIT_IGNORE_DIRS } from "../report-DOnKUw8G.js";
 import ts from "typescript";
 function git(root, args, opts = {}) {
   return new Promise((resolve2, reject) => {
@@ -59,11 +59,17 @@ async function commitToNewLocalBranch(root, args) {
     throw new Error(`Refusing to write branch "${args.branch}": ${err.message}`);
   }
   if (await branchExists(root, args.branch)) throw new Error(`Branch "${args.branch}" already exists. Pick another title or delete it first.`);
-  const baseSha = (await git(root, ["rev-parse", "--verify", `${args.base}^{commit}`])).trim();
+  const { sha, parent } = await commitTree(root, args);
+  await git(root, ["update-ref", `refs/heads/${args.branch}`, sha, ""]);
+  const diff = await git(root, ["diff", parent, sha]);
+  return { sha, diff };
+}
+async function commitTree(root, args) {
+  const parent = (await git(root, ["rev-parse", "--verify", `${args.base}^{commit}`])).trim();
   const dir = await mkdtemp(join(tmpdir(), "bridge-index-"));
   const env = { GIT_INDEX_FILE: join(dir, "index") };
   try {
-    await git(root, ["read-tree", baseSha], { env });
+    await git(root, ["read-tree", parent], { env });
     for (const f of args.files) {
       if (f.content === null) {
         await git(root, ["update-index", "--force-remove", f.path], { env });
@@ -74,10 +80,8 @@ async function commitToNewLocalBranch(root, args) {
     }
     const tree = (await git(root, ["write-tree"], { env })).trim();
     const ident = await identityEnv(root);
-    const sha = (await git(root, ["commit-tree", tree, "-p", baseSha, "-F", "-"], { input: args.message, env: ident })).trim();
-    await git(root, ["update-ref", `refs/heads/${args.branch}`, sha, ""]);
-    const diff = await git(root, ["diff", baseSha, sha]);
-    return { sha, diff };
+    const sha = (await git(root, ["commit-tree", tree, "-p", parent, "-F", "-"], { input: args.message, env: ident })).trim();
+    return { sha, parent };
   } finally {
     await rm(dir, { recursive: true, force: true });
   }
@@ -3611,6 +3615,188 @@ function generateRepoComponentSpecs(root, names) {
 }
 const serializeComponentSpecs = (f) => `${JSON.stringify(f, null, 2)}
 `;
+function gitCode(root, args) {
+  return new Promise((resolve2) => {
+    execFile("git", args, { cwd: root, maxBuffer: 32 * 1024 * 1024 }, (err, stdout, stderr) => {
+      const code = err ? typeof err.code === "number" ? err.code : -1 : 0;
+      resolve2({ code, stdout, stderr });
+    });
+  });
+}
+async function treeEntry(root, ref, path) {
+  const r = await gitCode(root, ["ls-tree", ref, "--", path]);
+  const m = /^(\d+) (\w+) ([0-9a-f]+)\t/.exec(r.stdout);
+  return r.code === 0 && m ? { mode: m[1], type: m[2], sha: m[3] } : null;
+}
+const prefixes = (path) => path.split("/").map((_, i, segs) => segs.slice(0, i + 1).join("/"));
+async function mergeText(root, input) {
+  const dir = await mkdtemp(join(tmpdir(), "bridge-merge-"));
+  try {
+    const [o, b, t] = ["current", "base", "suggested"].map((n) => join(dir, n));
+    await Promise.all([writeFile(o, input.ours), writeFile(b, input.base), writeFile(t, input.theirs)]);
+    const r = await gitCode(root, ["merge-file", "-p", "-L", "current", "-L", "base", "-L", "suggested", o, b, t]);
+    if (r.code < 0 || r.code > 127) throw new Error(`git merge-file failed: ${r.stderr.trim() || `exit ${r.code}`}`);
+    return { clean: r.code === 0, text: r.stdout, conflicts: r.code };
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+async function fileDiff(path, before, after) {
+  if (before === after) return "";
+  const dir = await mkdtemp(join(tmpdir(), "bridge-diff-"));
+  try {
+    const side = async (name, text) => {
+      if (text === null) return "/dev/null";
+      const p = join(dir, name, path);
+      await mkdir(dirname(p), { recursive: true });
+      await writeFile(p, text);
+      return `${name}/${path}`;
+    };
+    const a = await side("a", before);
+    const b = await side("b", after);
+    const r = await new Promise((resolve2) => execFile("git", ["diff", "--no-index", "--no-color", "--src-prefix=", "--dst-prefix=", "--", a, b], { cwd: dir, maxBuffer: 32 * 1024 * 1024 }, (_e, stdout) => resolve2({ stdout })));
+    return r.stdout;
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+function gitWorkspace(root, opts = {}) {
+  const { ref } = opts;
+  let fetched = false;
+  return {
+    async read(path) {
+      if (ref) {
+        const e = await treeEntry(root, ref, path);
+        if (!e || e.type !== "blob" || e.mode === "120000") return null;
+        return { text: await git(root, ["cat-file", "blob", e.sha]), sha: e.sha };
+      }
+      try {
+        const st = await lstat(join(root, path));
+        if (!st.isFile()) return null;
+        const text = await readFile(join(root, path), "utf8");
+        return { text, sha: gitBlobSha(text) };
+      } catch {
+        return null;
+      }
+    },
+    async readAt(at, path) {
+      if ((await gitCode(root, ["cat-file", "-e", `${at}^{commit}`])).code !== 0 && !fetched) {
+        fetched = true;
+        await gitCode(root, ["fetch", "--no-tags", "--quiet", "origin", at]);
+      }
+      const e = await treeEntry(root, at, path);
+      if (e?.type === "blob") return git(root, ["cat-file", "blob", e.sha]);
+      return opts.readBase ? opts.readBase(path, at) : null;
+    },
+    async list() {
+      if (ref) return listFilesAt(root, ref);
+      const out = await git(root, ["ls-files", "-z", "--cached", "--others", "--exclude-standard"]);
+      const all = [...new Set(out.split("\0").filter(Boolean))];
+      const present = await Promise.all(all.map((p) => lstat(join(root, p)).then((s) => s.isFile(), () => false)));
+      return all.filter((_, i) => present[i]);
+    },
+    async isSymlink(path) {
+      for (const p of prefixes(path)) {
+        if (ref) {
+          const e = await treeEntry(root, ref, p);
+          if (!e) return false;
+          if (e.mode === "120000") return true;
+        } else {
+          try {
+            if ((await lstat(join(root, p))).isSymbolicLink()) return true;
+          } catch {
+            return false;
+          }
+        }
+      }
+      return false;
+    },
+    merge: (input) => mergeText(root, input)
+  };
+}
+const COMMIT_TYPE = { "token-change": "feat(tokens)", docs: "docs", "component-spec": "feat", brand: "feat(tokens)", revert: "revert", config: "chore(config)" };
+function commitMessage(plan, n) {
+  const p = plan.payload;
+  const type = `${COMMIT_TYPE[p.kind] ?? "chore"}${p.tier.bump === "major" ? "!" : ""}`;
+  return [`${type}: ${p.title.trim()}`, "", p.summary.trim(), "", `Applies Bridge suggestion #${n} (version ${plan.payloadSha.slice(0, 7)}).`].filter((l, i, a) => !(l === "" && a[i - 1] === "")).join("\n");
+}
+async function readConfigAt(ws) {
+  const text = (await ws.read(CONFIG_FILE))?.text;
+  if (!text) throw new Error(`No ${CONFIG_FILE} here: run \`bridge init\` first, or apply from the repository root.`);
+  return loadConfig(text);
+}
+async function applySuggestionLocally(input) {
+  const mode = input.mode ?? "branch";
+  const base = input.base ?? "HEAD";
+  const { root } = input;
+  const wsOpts = { readBase: input.readBase };
+  const ws = gitWorkspace(root, mode === "write" ? wsOpts : { ...wsOpts, ref: base });
+  const config = input.config ?? await readConfigAt(ws);
+  const planFor = (workspace) => planSuggestionApply({ ...input, config, workspace });
+  const plan = await planFor(ws);
+  const at = (input.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()))();
+  const result = (status, rest = {}) => ({ status, exitCode: plan.exitCode, message: plan.message, plan, ...rest });
+  if (plan.outcome !== "ready") return result(plan.outcome);
+  const readNow = async (path) => (await ws.read(path))?.text ?? null;
+  const diffOf = async () => (await Promise.all(plan.writes.map(async (w) => fileDiff(w.path, await readNow(w.path), w.content)))).join("");
+  if (input.dryRun) return result("dry-run", { message: `Dry run: ${plan.message.replace(/^Ready: /, "")} Nothing written.`, diff: await diffOf() });
+  if (mode === "patch") {
+    const { sha } = await commitTree(root, { base, message: commitMessage(plan, input.number), files: plan.writes });
+    const patch = await git(root, ["format-patch", "-1", "--stdout", sha]);
+    return result("patch", { message: "Patch ready: apply it with `git am`.", patch, commit: sha });
+  }
+  if (mode === "write") {
+    const paths = plan.writes.map((w) => w.path);
+    const dirty = (await git(root, ["status", "--porcelain", "-z", "--", ...paths])).split("\0").filter((l) => l.length > 3).map((l) => l.slice(3));
+    if (dirty.length) {
+      return result("refused", {
+        exitCode: 1,
+        message: `Not written: these files have uncommitted changes: ${dirty.join(", ")}. Commit or stash them, or apply on a branch instead.`
+      });
+    }
+    const diff = await diffOf();
+    for (const w of plan.writes) {
+      const full = join(root, w.path);
+      if (w.content === null) await rm(full, { force: true });
+      else {
+        await mkdir(dirname(full), { recursive: true });
+        await writeFile(full, w.content);
+      }
+    }
+    return result("written", {
+      message: `Written: ${paths.length} file(s) in the working tree. Review them, commit, and say "Closes #${input.number}" in the pull request.`,
+      written: paths,
+      diff,
+      appliedComment: suggestionAppliedComment(plan, { by: input.by, at })
+    });
+  }
+  const prefix = config.governance.branchPrefix;
+  const wanted = input.branch ?? `${prefix}suggestion-${input.number}-${slugify(plan.payload.title, 40)}`;
+  let branch = wanted;
+  for (let i = 2; await branchExists(root, branch); i++) {
+    const there = await planFor(gitWorkspace(root, { ...wsOpts, ref: branch }));
+    if (there.outcome === "already-applied") {
+      const commit = (await git(root, ["rev-parse", `refs/heads/${branch}`])).trim();
+      return result("branch-exists", {
+        exitCode: 0,
+        message: `Already on ${branch}: that branch has every change of this suggestion. Push it and open a pull request that says "Closes #${input.number}".`,
+        branch,
+        commit,
+        appliedComment: suggestionAppliedComment(plan, { by: input.by, branch, commit, at })
+      });
+    }
+    branch = `${wanted}-${i}`;
+  }
+  const protectedBranches = [.../* @__PURE__ */ new Set([...protectedBranchesOf(config), baseBranchOf(config)])];
+  const res = await commitToNewLocalBranch(root, { base, branch, message: commitMessage(plan, input.number), files: plan.writes, protectedBranches, branchPrefix: prefix });
+  return result("branch-created", {
+    message: `Applied on ${branch}, your working tree is untouched. Push it and open a pull request that says "Closes #${input.number}".`,
+    branch,
+    commit: res.sha,
+    diff: res.diff,
+    appliedComment: suggestionAppliedComment(plan, { by: input.by, branch, commit: res.sha, at })
+  });
+}
 export {
   COMMON_ICONS,
   DEFAULT_STATE,
@@ -3618,10 +3804,12 @@ export {
   INHERITED,
   MEDIA_SLOT,
   UnsupportedComponentError,
+  applySuggestionLocally,
   branchExists,
   changedProperties,
   collectAuditFiles,
   commitToNewLocalBranch,
+  commitTree,
   computeValues,
   currentBranch,
   declaredFor,
@@ -3629,6 +3817,7 @@ export {
   draftedSpec,
   entryFor,
   expandDecl,
+  fileDiff,
   findDesignSystemRoot,
   fixCss,
   generateAllComponentSpecs,
@@ -3638,6 +3827,7 @@ export {
   generateRepoComponentSpecs,
   generateSlots,
   git,
+  gitWorkspace,
   isGitRepo,
   jsxText,
   listFilesAt,
@@ -3648,6 +3838,7 @@ export {
   localTags,
   matchComplex,
   mediaApplies,
+  mergeText,
   motionNotes,
   openingTransitions,
   originRepo,