@synovitec/trellis 0.0.0-stage → 0.6.0-rc.2

package/src/agents/git.mjs

@@ -0,0 +1,241 @@
+// The repository as git sees it: what changed during a session, whoever changed it. The rules
+// read edits from here rather than from the transcript, so a write through the shell, an MCP
+// editor or a subagent counts the same as one through the Edit tool.
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+/**
+ * @param {string} root
+ * @param {string[]} args
+ * @returns {string | null} stdout, or null when git fails or is absent
+ */
+export function git(root, args) {
+  const r = spawnSync("git", args, { cwd: root, encoding: "utf8", maxBuffer: 64 * 1024 * 1024, windowsHide: true });
+  return r.status === 0 ? r.stdout : null;
+}
+
+/** @param {string} root */
+export const headOf = (root) => git(root, ["rev-parse", "--verify", "-q", "HEAD"])?.trim() || null;
+
+/** @param {string} root */
+export const isRepo = (root) => git(root, ["rev-parse", "--is-inside-work-tree"])?.trim() === "true";
+
+/** The folder git runs hooks from, worktrees, submodules and core.hooksPath included. @param {string} root */
+export function hooksDir(root) {
+  const p = git(root, ["rev-parse", "--git-path", "hooks"])?.trim();
+  return p ? p.replace(/\\/g, "/") : null;
+}
+
+/** @param {string} root @param {string} rel */
+function hashOf(root, rel) {
+  try {
+    return createHash("sha1").update(readFileSync(join(root, rel))).digest("hex");
+  } catch {
+    return "deleted";
+  }
+}
+
+/**
+ * Files that differ from HEAD right now (modified, staged, untracked, deleted), with a hash of
+ * their content, so a later edit to a file that was already dirty is still seen.
+ * @param {string} root
+ * @returns {Record<string, string>}
+ */
+export function dirtyFiles(root) {
+  const out = git(root, ["status", "--porcelain=v1", "-z", "--untracked-files=all"]);
+  /** @type {Record<string, string>} */
+  const files = {};
+  if (out == null) return files;
+  const parts = out.split("\0");
+  for (let i = 0; i < parts.length; i++) {
+    const entry = parts[i];
+    if (entry.length < 4) continue;
+    const status = entry.slice(0, 2);
+    const path = entry.slice(3);
+    files[path] = hashOf(root, path);
+    // A rename carries its source as the next field.
+    if (status[0] === "R" || status[0] === "C") i++;
+  }
+  return files;
+}
+
+/**
+ * Files git has been told not to look at: assume-unchanged (lowercase tag) or skip-worktree (S).
+ * A change hidden this way is still a change, and hiding one mid-session is itself a finding.
+ * @param {string} root
+ */
+export function flaggedFiles(root) {
+  const out = git(root, ["ls-files", "-v", "-z"]) ?? "";
+  return out.split("\0").filter((l) => /^([a-z]|S) /.test(l)).map((l) => l.slice(2));
+}
+
+/** @param {string | null} out */
+const zList = (out) => (out ?? "").split("\0").filter(Boolean).map((p) => p.replace(/\\/g, "/"));
+
+/**
+ * What git ignores and does not track, whatever the rule (a .gitignore, core.excludesFile,
+ * info/exclude), one entry per ignored folder (`node_modules/`), so the list stays short; with
+ * `under`, every file below those paths instead.
+ * @param {string} root
+ * @param {string[]} [under]
+ */
+export function ignoredEntries(root, under) {
+  if (under) return under.length ? zList(git(root, ["ls-files", "--others", "--ignored", "--exclude-standard", "-z", "--", ...under])) : [];
+  return zList(git(root, ["ls-files", "--others", "--ignored", "--exclude-standard", "--directory", "--no-empty-directory", "-z"]));
+}
+
+/**
+ * A fingerprint of the rules that decide what git ignores, info/exclude aside (watched on its
+ * own): every .gitignore git reads (tracked, untracked, or one that ignores itself) and
+ * core.excludesFile with its content. Two equal fingerprints ignore the same files.
+ * @param {string} root
+ */
+export function ignoreRules(root) {
+  const files = new Set([
+    ...zList(git(root, ["ls-files", "--cached", "-z", "--", ":(glob)**/.gitignore"])),
+    ...zList(git(root, ["ls-files", "--others", "--exclude-standard", "-z", "--", ":(glob)**/.gitignore"])),
+    ...ignoredEntries(root).filter((p) => p === ".gitignore" || p.endsWith("/.gitignore")),
+  ]);
+  const read = (/** @type {string} */ p) => {
+    try {
+      return readFileSync(p, "utf8");
+    } catch {
+      return "";
+    }
+  };
+  const excludesFile = git(root, ["config", "--path", "--get", "core.excludesFile"])?.trim() ?? "";
+  const parts = [...files].sort().map((f) => `${f}\n${read(join(root, f))}`);
+  parts.push(`core.excludesFile=${excludesFile}\n${excludesFile ? read(excludesFile) : ""}`);
+  return createHash("sha256").update(parts.join("\0")).digest("hex");
+}
+
+/** .git/info/exclude's text, wherever this checkout keeps it. @param {string} root */
+export function excludeText(root) {
+  const p = git(root, ["rev-parse", "--git-path", "info/exclude"])?.trim();
+  if (!p) return null;
+  try {
+    return readFileSync(join(root, p), "utf8");
+  } catch {
+    try {
+      return readFileSync(p, "utf8");
+    } catch {
+      return null;
+    }
+  }
+}
+
+/** @param {string} root */
+export const stashCount = (root) => (git(root, ["stash", "list"]) ?? "").split(/\r?\n/).filter(Boolean).length;
+
+/**
+ * Where the repository stood when the session started: the commits its local branches, HEAD
+ * and the stash pointed at, and how long HEAD's reflog was. Commit dates play no part: the
+ * agent sets them (`GIT_COMMITTER_DATE`), so a session's commits are defined by reachability.
+ * @param {string} root
+ */
+export function startPoint(root) {
+  const out = git(root, ["for-each-ref", "--format=%(objectname)", "refs/heads", "refs/stash"]) ?? "";
+  const head = headOf(root);
+  return {
+    tips: [...new Set([...out.split(/\r?\n/).filter(Boolean), ...(head ? [head] : [])])],
+    remotes: lines(git(root, ["for-each-ref", "--format=%(objectname)", "refs/remotes"])),
+    reflog: reflogShas(root).length,
+  };
+}
+
+/** @param {string | null} out */
+const lines = (out) => [...new Set((out ?? "").split(/\r?\n/).filter(Boolean))];
+
+/** HEAD's reflog, newest first. @param {string} root */
+const reflogShas = (root) => (git(root, ["reflog", "--format=%H"]) ?? "").split(/\r?\n/).filter(Boolean);
+
+/**
+ * Commits a remote-tracking ref was moved to by a fetch or a pull, read from that ref's reflog:
+ * work that came from the remote. A push writes "update by push", `update-ref` writes what it is
+ * told; neither reads as received, so what the session sent away stays the session's.
+ * @param {string} root
+ */
+function received(root) {
+  const shas = [];
+  for (const ref of lines(git(root, ["for-each-ref", "--format=%(refname)", "refs/remotes"]))) {
+    for (const entry of lines(git(root, ["reflog", "show", "--format=%H %gs", ref, "--"]))) {
+      const [sha, ...msg] = entry.split(" ");
+      if (/^(fetch|pull)\b/.test(msg.join(" "))) shas.push(sha);
+    }
+  }
+  return [...new Set(shas)];
+}
+
+/**
+ * The revision set of the session's own commits: what local branches and HEAD's new reflog
+ * entries reach, minus where things stood at the start, minus what the remotes held then, minus
+ * what arrived from a remote since (work pulled from a teammate is theirs). What the session
+ * pushed is still the session's. A commit on another branch, one undone by `reset`, and one
+ * with a backdated date all belong to it.
+ * @param {string} root
+ * @param {{ tips?: string[], remotes?: string[], reflog?: number }} start
+ * @returns {string[]} git log / rev-list arguments
+ */
+export function sessionRevs(root, start) {
+  const log = reflogShas(root);
+  const fresh = log.slice(0, Math.max(0, log.length - (start.reflog ?? 0)));
+  const known = [...(start.tips ?? []), ...(start.remotes ?? []), ...received(root)];
+  return ["--branches", ...new Set(fresh), ...new Set(known.map((t) => `^${t}`))];
+}
+
+/**
+ * The session's commits, newest first.
+ * @param {string} root
+ * @param {{ tips?: string[], reflog?: number }} start
+ */
+export function sessionCommits(root, start) {
+  if (!start.tips) return [];
+  return (git(root, ["rev-list", ...sessionRevs(root, start)]) ?? "").split(/\r?\n/).filter(Boolean);
+}
+
+/**
+ * Every file changed since the session's snapshot, by content: files the session's commits
+ * touched (on any branch), files dirty now whose content differs from the start, files hidden
+ * from git's status by an index flag, and files put away in a stash made during the session.
+ * @param {string} root
+ * @param {{ head: string | null, dirty: Record<string, string>, stashes?: number, tips?: string[], remotes?: string[], reflog?: number }} snapshot
+ * @returns {Array<{ path: string, hash: string }>}
+ */
+export function changedSince(root, snapshot) {
+  const paths = new Set();
+  if (snapshot.tips) {
+    const committed = git(root, ["log", "--no-merges", "--name-only", "--format=", "-z", ...sessionRevs(root, snapshot)]);
+    // A file that was already dirty at the start and committed as it was is not a change.
+    for (const p of (committed ?? "").split(/[\0\n]/)) if (p && snapshot.dirty[p] !== hashOf(root, p)) paths.add(p);
+  } else if (snapshot.head) {
+    const committed = git(root, ["diff", "--name-only", "-z", snapshot.head, "HEAD"]);
+    for (const p of (committed ?? "").split("\0")) if (p && snapshot.dirty[p] !== hashOf(root, p)) paths.add(p);
+  }
+  const now = dirtyFiles(root);
+  for (const [p, hash] of Object.entries(now)) if (snapshot.dirty[p] !== hash) paths.add(p);
+  // A file dirty at the start and restored since changed too.
+  for (const p of Object.keys(snapshot.dirty)) if (!(p in now) && snapshot.dirty[p] !== hashOf(root, p)) paths.add(p);
+  for (const p of flaggedFiles(root)) {
+    const blob = (git(root, ["ls-files", "-s", "--", p]) ?? "").split(/\s+/)[1];
+    const work = git(root, ["hash-object", "--", p])?.trim() ?? "deleted";
+    if (blob !== work && snapshot.dirty[p] !== hashOf(root, p)) paths.add(p);
+  }
+  const fresh = stashCount(root) - (snapshot.stashes ?? 0);
+  for (let i = 0; i < fresh; i++) {
+    const files = git(root, ["stash", "show", "--name-only", "--include-untracked", `stash@{${i}}`]) ?? "";
+    for (const p of files.split(/\r?\n/)) if (p) paths.add(p);
+  }
+  return [...paths].map((path) => ({ path, hash: hashOf(root, path) }));
+}
+
+/** A file's content hash now, or "deleted". @param {string} root @param {string} rel */
+export function contentHash(root, rel) {
+  return hashOf(root, rel);
+}
+
+/** A file's text at a revision, or null. @param {string} root @param {string} rev @param {string} path */
+export function fileAt(root, rev, path) {
+  return git(root, ["show", `${rev}:${path}`]);
+}

package/src/agents/glob.mjs

@@ -0,0 +1,41 @@
+// A small glob, enough for path rules in a config: `**` (any depth), `*` (within a segment),
+// `?`, and `{a,b}` alternatives. No dependency, so the package keeps none of its own.
+
+/** @param {string} glob */
+export function globToRegExp(glob) {
+  let re = "";
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*" && glob[i + 1] === "*") {
+      // `**/` matches zero or more whole segments; a trailing `**` matches anything.
+      if (glob[i + 2] === "/") {
+        re += "(?:.*/)?";
+        i += 2;
+      } else {
+        re += ".*";
+        i += 1;
+      }
+    } else if (c === "*") re += "[^/]*";
+    else if (c === "?") re += "[^/]";
+    else if (c === "{") {
+      const end = glob.indexOf("}", i);
+      if (end === -1) re += "\\{";
+      else {
+        re += `(?:${glob.slice(i + 1, end).split(",").map(escape).join("|")})`;
+        i = end;
+      }
+    } else re += escape(c);
+  }
+  return new RegExp(`^${re}$`);
+}
+
+/** @param {string} s */
+const escape = (s) => s.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+
+/**
+ * @param {string} path
+ * @param {string[]} globs
+ */
+export function matchesAny(path, globs) {
+  return globs.some((g) => globToRegExp(g).test(path));
+}