@workit-dev/core 0.0.1 → 1.0.0

package/src/test-audit-mocks.ts

@@ -0,0 +1,309 @@
+type Node = { type: string; start: number; end: number; loc: Loc; [key: string]: any };
+type Loc = { start: { line: number }; end: { line: number } };
+
+/** A parsed test file: the shape `@babel/parser` returns, as `workit test-audit` passes it in. */
+export type ParsedTest = { source: string; program: Node; comments: Node[] };
+
+export const MOCK_RULES = {
+  "mock-call-order":
+    "Asserts the call count or call order of an internal collaborator: couples the test to the implementation",
+  "private-access": "Reaches into private state or a test-only export of the code under test",
+} as const;
+export type MockRuleId = keyof typeof MOCK_RULES;
+
+export type MockFinding = {
+  rule: MockRuleId;
+  severity: "medium" | "low";
+  confidence: "high" | "medium" | "low";
+  file: string;
+  line: number;
+  test: string | null;
+  why: string;
+  suggestion: string;
+  snippet: string;
+};
+
+const ORDER_MATCHERS = new Set([
+  "toHaveBeenNthCalledWith",
+  "nthCalledWith",
+  "toHaveBeenCalledBefore",
+  "toHaveBeenCalledAfter",
+  "calledBefore",
+  "calledAfter",
+  "calledImmediatelyBefore",
+  "calledImmediatelyAfter",
+]);
+const COUNT_MATCHERS = new Set([
+  "toHaveBeenCalledTimes",
+  "toBeCalledTimes",
+  "toHaveBeenCalledOnce",
+  "toHaveBeenCalledExactlyOnceWith",
+  "calledOnce",
+  "calledTwice",
+  "calledThrice",
+]);
+const MOCK_FACTORIES = /^(?:mock|jest\.fn|vi\.fn|sinon\.(?:spy|stub|fake)|spy|stub|fn)$/;
+const SPY_CALLS = /^(?:spyOn|jest\.spyOn|vi\.spyOn|mock\.method|sinon\.(?:spy|stub|replace))$/;
+const MODULE_MOCKS =
+  /^(?:mock\.module|jest\.(?:mock|doMock|unstable_mockModule)|vi\.(?:mock|doMock)|td\.replace(?:Esm)?)$/;
+const TEST_CALLEES = /^(?:test|it|specify)(?:\.(?:only|each|concurrent|serial|failing))?$/;
+const TEST_ONLY_EXPORT = /^(?:_\w|\w*(?:ForTest(?:s|ing)?|TestOnly|_test|__test__|Internals?)$)/;
+const PRIVATE_MEMBER = /^_{1,2}[A-Za-z]/;
+const NOT_PRIVATE = new Set(["__proto__", "__esModule", "__dirname", "__filename"]);
+const SKIP_KEYS = new Set([
+  "loc",
+  "start",
+  "end",
+  "extra",
+  "range",
+  "leadingComments",
+  "trailingComments",
+  "innerComments",
+  "typeAnnotation",
+  "typeParameters",
+  "typeArguments",
+  "returnType",
+]);
+
+const isNode = (value: unknown): value is Node =>
+  typeof value === "object" && value !== null && typeof (value as Node).type === "string";
+
+function walk(root: Node, visit: (node: Node, ancestors: readonly Node[]) => void) {
+  const stack: [Node, Node[]][] = [[root, []]];
+  while (stack.length > 0) {
+    const [node, ancestors] = stack.pop()!;
+    visit(node, ancestors);
+    const below = [...ancestors, node];
+    for (const key of Object.keys(node)) {
+      if (SKIP_KEYS.has(key)) continue;
+      const value = node[key];
+      if (Array.isArray(value)) {
+        for (const item of value.toReversed()) if (isNode(item)) stack.push([item, below]);
+      } else if (isNode(value)) stack.push([value, below]);
+    }
+  }
+}
+
+function dotted(node: Node | null | undefined): string | null {
+  if (!node) return null;
+  if (node.type === "Identifier") return node.name;
+  if (node.type === "MemberExpression" && !node.computed && node.property.type === "Identifier") {
+    const object = dotted(node.object);
+    return object ? `${object}.${node.property.name}` : null;
+  }
+  return null;
+}
+
+function unwrap(node: Node | null | undefined): Node | null {
+  let current = node ?? null;
+  while (
+    current &&
+    [
+      "AwaitExpression",
+      "TSAsExpression",
+      "TSNonNullExpression",
+      "ParenthesizedExpression",
+    ].includes(current.type)
+  )
+    current = current.type === "AwaitExpression" ? current.argument : current.expression;
+  return current;
+}
+
+const internalSpecifier = (spec: string): boolean => /^(?:\.{1,2}\/|@\/|~\/|#|src\/)/.test(spec);
+
+const literal = (node: Node | undefined): string | null =>
+  node?.type === "StringLiteral" ? node.value : null;
+
+type Doubles = {
+  internalImports: Map<string, string>;
+  internalMocks: Set<string>;
+  mocks: Set<string>;
+};
+
+function collectDoubles(program: Node): Doubles {
+  const internalImports = new Map<string, string>();
+  const mockedModules = new Set<string>();
+  const internalMocks = new Set<string>();
+  const mocks = new Set<string>();
+  for (const statement of program.body as Node[])
+    if (statement.type === "ImportDeclaration" && internalSpecifier(statement.source.value))
+      for (const spec of statement.specifiers as Node[])
+        internalImports.set(spec.local.name, statement.source.value);
+  walk(program, (node) => {
+    if (node.type !== "CallExpression") return;
+    const name = dotted(node.callee);
+    const spec = literal(node.arguments[0]);
+    if (name && MODULE_MOCKS.test(name) && spec && internalSpecifier(spec)) mockedModules.add(spec);
+  });
+  for (const [local, spec] of internalImports)
+    if (mockedModules.has(spec)) {
+      internalMocks.add(local);
+      mocks.add(local);
+    }
+  walk(program, (node) => {
+    const call = node.type === "VariableDeclarator" ? unwrap(node.init) : node;
+    if (call?.type !== "CallExpression") return;
+    const name = dotted(call.callee);
+    if (!name) return;
+    const bound =
+      node.type === "VariableDeclarator" && node.id.type === "Identifier" ? node.id.name : null;
+    if (SPY_CALLS.test(name)) {
+      const target = dotted(call.arguments[0]);
+      const method = literal(call.arguments[1]);
+      const internal = !!target && internalImports.has(target.split(".")[0]);
+      for (const key of [bound, target && method ? `${target}.${method}` : null])
+        if (key) {
+          mocks.add(key);
+          if (internal) internalMocks.add(key);
+        }
+    } else if (bound && MOCK_FACTORIES.test(name)) mocks.add(bound);
+  });
+  return { internalImports, internalMocks, mocks };
+}
+
+function subject(node: Node | null): string | null {
+  const target = unwrap(node);
+  if (!target) return null;
+  const name = dotted(target);
+  if (name)
+    return name.replace(/\.(?:mock\.(?:calls|invocationCallOrder)|callCount|args)(?:\..*)?$/, "");
+  if (target.type === "MemberExpression") return subject(target.object);
+  return null;
+}
+
+function expectation(node: Node): { actual: Node | null; matcher: string } | null {
+  if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression") return null;
+  if (node.callee.property.type !== "Identifier") return null;
+  const matcher = node.callee.property.name;
+  let current: Node = node.callee.object;
+  while (current.type === "MemberExpression") current = current.object;
+  if (current.type !== "CallExpression" || dotted(current.callee) !== "expect") return null;
+  return { actual: current.arguments[0] ?? null, matcher };
+}
+
+function enclosingTest(ancestors: readonly Node[]): string | null {
+  for (const node of ancestors.toReversed()) {
+    if (node.type !== "CallExpression") continue;
+    const callee = node.callee.type === "CallExpression" ? node.callee.callee : node.callee;
+    const name = dotted(callee);
+    if (name && TEST_CALLEES.test(name)) return literal(node.arguments[0]) ?? "<anonymous>";
+  }
+  return null;
+}
+
+function mutedLines(comments: Node[]): Map<number, Set<string> | null> {
+  const lines = new Map<number, Set<string> | null>();
+  for (const comment of comments) {
+    const match = /workit-test-audit-ignore(?:\s+([\w\s,-]+?))?(?:\s+--|$)/.exec(comment.value);
+    if (!match) continue;
+    const rules = match[1]
+      ? new Set(match[1].split(/[\s,]+/).filter((rule) => rule in MOCK_RULES))
+      : null;
+    const set = rules && rules.size > 0 ? rules : null;
+    lines.set(comment.loc.start.line, set);
+    lines.set(comment.loc.end.line + 1, set);
+  }
+  return lines;
+}
+
+/**
+ * The `mock-call-order` and `private-access` findings of one parsed test
+ * file. Call order on any double, and call counts on a double that replaces
+ * the code under test's own module, couple a test to how the code works
+ * rather than what it returns.
+ */
+export function auditMockUse(parsed: ParsedTest, file: string): MockFinding[] {
+  const doubles = collectDoubles(parsed.program);
+  const muted = mutedLines(parsed.comments);
+  const findings: MockFinding[] = [];
+  const snippet = (node: Node) =>
+    parsed.source.slice(node.start, node.end).replace(/\s+/g, " ").slice(0, 120);
+  const push = (finding: Omit<MockFinding, "file">) => {
+    const mute = muted.has(finding.line) ? muted.get(finding.line) : undefined;
+    if (mute === null || mute?.has(finding.rule)) return;
+    findings.push({ file, ...finding });
+  };
+
+  walk(parsed.program, (node, ancestors) => {
+    const assertion = expectation(node);
+    const sinonAssert =
+      node.type === "CallExpression"
+        ? /^sinon\.assert\.(callOrder|callCount)$/.exec(dotted(node.callee) ?? "")
+        : null;
+    let kind: "order" | "count" | null = null;
+    let target: string | null = null;
+    if (assertion) {
+      let actual = unwrap(assertion.actual);
+      while (actual?.type === "MemberExpression" && actual.computed) actual = actual.object;
+      const source = dotted(actual) ?? "";
+      if (ORDER_MATCHERS.has(assertion.matcher) || source.includes(".mock.invocationCallOrder"))
+        kind = "order";
+      else if (
+        COUNT_MATCHERS.has(assertion.matcher) ||
+        /\.(?:mock\.calls\.length|callCount)$/.test(source)
+      )
+        kind = "count";
+      target = subject(assertion.actual);
+    } else if (sinonAssert) {
+      kind = sinonAssert[1] === "callOrder" ? "order" : "count";
+      target = subject(node.arguments[0]);
+    }
+    if (kind && target) {
+      const internal = doubles.internalMocks.has(target);
+      if (internal || (kind === "order" && doubles.mocks.has(target)))
+        push({
+          rule: "mock-call-order",
+          severity: internal ? "medium" : "low",
+          confidence: internal ? "high" : "medium",
+          line: node.loc.start.line,
+          test: enclosingTest(ancestors),
+          why: internal
+            ? `Asserts the call ${kind} of ${target}, a double of the code under test's own module: a refactor that keeps the behavior breaks it.`
+            : `Asserts the order in which ${target} was called: the order between collaborators is an implementation detail unless a caller depends on it.`,
+          suggestion:
+            "Assert the observable result (return value, written state, the message a boundary received) instead; keep a call count only for a boundary contract such as retries or idempotency.",
+          snippet: snippet(node),
+        });
+    }
+
+    if (node.type === "MemberExpression" && node.object.type !== "ThisExpression") {
+      const name =
+        !node.computed && node.property.type === "Identifier"
+          ? node.property.name
+          : literal(node.property);
+      if (name && PRIVATE_MEMBER.test(name) && !NOT_PRIVATE.has(name))
+        push({
+          rule: "private-access",
+          severity: "low",
+          confidence: "medium",
+          line: node.loc.start.line,
+          test: enclosingTest(ancestors),
+          why: `Reads ${name}, a private member: the test breaks when the internals are renamed, though the behavior is unchanged.`,
+          suggestion:
+            "Drive the behavior through the public API and assert what a caller observes.",
+          snippet: snippet(node),
+        });
+    }
+  });
+
+  for (const statement of parsed.program.body as Node[]) {
+    if (statement.type !== "ImportDeclaration" || !internalSpecifier(statement.source.value))
+      continue;
+    for (const spec of statement.specifiers as Node[]) {
+      const imported = spec.imported?.name ?? spec.imported?.value ?? null;
+      if (imported && TEST_ONLY_EXPORT.test(imported))
+        push({
+          rule: "private-access",
+          severity: "low",
+          confidence: "medium",
+          line: spec.loc.start.line,
+          test: null,
+          why: `Imports ${imported}, a test-only or internal export: the test pins internals the public API does not promise.`,
+          suggestion:
+            "Test through the public export, or move the logic into its own module with a real public API.",
+          snippet: snippet(statement),
+        });
+    }
+  }
+  return findings.toSorted((a, b) => a.line - b.line);
+}

package/src/verdict-cover.ts

@@ -0,0 +1,151 @@
+// Stack-wide verdicts (#334, decision mvk5q3io): one verifier at the top of
+// a stack, after its last push, covers the lower PRs it judged. A branch with
+// no accepted verdict of its own is covered by a branch above it in a cached
+// stack (`<store>/stacks/*.json`, S12) when:
+//
+//   - that branch has an accepted independent verdict now (fresh or carried);
+//   - the verdict's session is not an author of the lower branch either;
+//   - every commit of the lower branch since its fork from the trunk has a
+//     verbatim patch-id (whitespace counts) among the commits of the judged
+//     head (the verdict's own head, not the upper branch's current tip): the
+//     lower change was judged unchanged. No merge commits, at least one
+//     non-empty commit;
+//   - the judged head holds exactly the lower branch's resulting files (no
+//     `<lower>..<judged>` difference in any file the lower branch changed):
+//     an upper commit that reverts or rewrites a lower file means the lower
+//     PR's own code was never judged;
+//   - the lower branch's own review lane is below full (decision B3): a risk
+//     path or a large change needs its own verdict.
+//
+// A lower branch that changed after the verdict (a new commit, an amend, a
+// conflict resolved differently) holds a patch-id the judged head lacks and
+// is not covered. When git cannot read any of this, nothing is covered. A current independent failure or a tampered ledger on the
+// lower branch is never covered over. `pr merge`, `stack land`, `stack
+// status`, `pr status` and `ledger check` read this; the Stop hook does not.
+import fs from "node:fs";
+import path from "node:path";
+import { branchLane } from "./core/policy/lane";
+import { commitPatchIds, diffRaw, mergeBase } from "./git/rev";
+import {
+  authorSessions,
+  authoredBy,
+  checkVerdicts,
+  defaultBase,
+  resolveCommit,
+  storeRoot,
+  type ReadRow,
+  type VerdictCheck,
+} from "./ledger";
+
+/** The verdict above `branch` in a stack that covers it. */
+export type StackCover = {
+  stack: string;
+  /** The upper branch the verdict was recorded on. */
+  branch: string;
+  verdictId: string;
+  /** The head that verdict judged. */
+  head: string;
+};
+
+export type CoveredCheck = VerdictCheck & { cover: StackCover | null };
+
+type Chain = { name: string; trunk: string; above: string[] };
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+/** The open branches above `branch` in each cached stack holding it, top first. */
+function chainsAbove(cwd: string, branch: string): Chain[] {
+  const root = storeRoot(cwd);
+  if (!root.ok) return [];
+  const dir = path.join(root.value.root, "stacks");
+  let names: string[] = [];
+  try {
+    names = fs.readdirSync(dir).filter((name) => name.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const chains: Chain[] = [];
+  for (const name of names.toSorted()) {
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(fs.readFileSync(path.join(dir, name), "utf8"));
+    } catch {
+      continue;
+    }
+    if (!isRecord(parsed) || !Array.isArray(parsed.branches) || typeof parsed.trunk !== "string")
+      continue;
+    const entries = parsed.branches.filter(isRecord);
+    const index = entries.findIndex((entry) => entry.branch === branch && !entry.merged);
+    if (index < 0) continue;
+    chains.push({
+      name: typeof parsed.name === "string" ? parsed.name : name,
+      trunk: parsed.trunk,
+      above: entries
+        .slice(index + 1)
+        .filter((entry) => typeof entry.branch === "string" && !entry.merged)
+        .map((entry) => entry.branch as string)
+        .toReversed(),
+    });
+  }
+  return chains;
+}
+
+/**
+ * Whether the verdict on `judged` covers the lower branch at `head` (see the
+ * header). Anything git cannot read is not covered.
+ */
+function covers(cwd: string, trunk: string, head: string, judged: string): boolean {
+  const trunkSha = [`origin/${trunk}`, trunk].map((ref) => resolveCommit(cwd, ref)).find(Boolean);
+  const ownFork = trunkSha ? mergeBase(cwd, trunkSha, head) : null;
+  const judgedFork = trunkSha ? mergeBase(cwd, trunkSha, judged) : null;
+  if (!ownFork || !judgedFork) return false;
+  const own = commitPatchIds(cwd, ownFork, head);
+  const top = commitPatchIds(cwd, judgedFork, judged);
+  if (!own || !top || own.merges > 0 || own.patchIds.length === 0) return false;
+  const judgedIds = new Set(top.patchIds);
+  if (!own.patchIds.every((id) => judgedIds.has(id))) return false;
+  // The judged tree holds exactly the lower branch's resulting files.
+  const changed = diffRaw(cwd, ownFork, head);
+  const between = changed ? diffRaw(cwd, head, judged) : null;
+  if (!changed || !between) return false;
+  const files = new Set(changed.map((entry) => entry.path));
+  if (between.some((entry) => files.has(entry.path))) return false;
+  return branchLane(cwd, { base: trunk, head }).lane !== "full";
+}
+
+/**
+ * `checkVerdicts` for `branch`, and when it has no accepted verdict of its
+ * own, the stack verdict that covers it (see the header): then `accepted`
+ * names that verdict and `cover` says where it came from.
+ */
+export function checkVerdictsCovered(
+  cwd: string,
+  branch: string,
+  rows: readonly ReadRow[],
+): CoveredCheck {
+  const check = checkVerdicts(cwd, branch, rows);
+  const blocked = check.accepted.reasons.some(
+    (reason) => reason === "failing_verdict" || reason === "ledger_tampered",
+  );
+  if (check.accepted.accepted || blocked || !check.head) return { ...check, cover: null };
+  let authors: Set<string> | null = null;
+  for (const chain of chainsAbove(cwd, branch))
+    for (const upper of chain.above) {
+      const verdict = checkVerdicts(cwd, upper, rows).accepted;
+      const row = verdict.accepted ? verdict.verdict : null;
+      const session = row?.actor.session;
+      if (!row?.head || !session || typeof row.id !== "string") continue;
+      authors ??= authorSessions(cwd, rows, branch, { base: defaultBase(cwd), head: check.head });
+      if (authoredBy(authors, session)) continue;
+      if (!covers(cwd, chain.trunk, check.head, row.head)) continue;
+      return {
+        ...check,
+        accepted: { accepted: true, verdict: row, reasons: [] },
+        review: "verified",
+        selfVerdict: null,
+        cover: { stack: chain.name, branch: upper, verdictId: row.id, head: row.head },
+      };
+    }
+  return { ...check, cover: null };
+}

package/src/worktree-deps.ts

@@ -0,0 +1,142 @@
+// Dependencies for a fresh worktree (issue #310): a linked worktree has no
+// node_modules, so a resolver walks up to whatever node_modules is above it
+// (the main checkout's, for a worktree nested inside it) and a workspace
+// package resolves to the main checkout's source: tests then run the wrong
+// code. Instead of a package-manager install, the worktree gets its own
+// node_modules that mirrors the main checkout's one level deep:
+//
+// - a symlink is copied as it is: a relative one (bun, npm and yarn link
+//   workspace packages as `../../packages/<name>`, and `.bin` entries as
+//   `../<pkg>/bin/x`) then resolves inside the worktree, which has the same
+//   layout; an absolute one into the main checkout (a Windows junction) is
+//   re-pointed at the worktree's counterpart;
+// - `@scope` directories and `.bin` are mirrored the same way, one level;
+// - anything else (a third-party package) is linked to the main checkout's,
+//   so installed packages are shared, never copied.
+//
+// It runs only where the worktree has no node_modules of its own and git
+// ignores node_modules there (else the links would show as changes and block
+// release). `git worktree remove` unlinks the links and never follows them.
+import fs from "node:fs";
+import path from "node:path";
+import { gitRun } from "./fanout";
+
+const MODULES = "node_modules";
+/** Directories searched for node_modules below the checkout root (packages/<name>). */
+const MAX_DEPTH = 2;
+
+export type LinkedDependencies = {
+  /** The main checkout the links point at. */
+  from: string;
+  /** The node_modules directories made, relative to the worktree. */
+  dirs: string[];
+  /** Links made across them. */
+  entries: number;
+  ms: number;
+};
+
+const within = (child: string, parent: string): boolean => {
+  const relative = path.relative(parent, child);
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+};
+
+/** node_modules directories of the main checkout, as paths relative to it. */
+function moduleDirs(main: string): string[] {
+  const out: string[] = [];
+  const walk = (relative: string, depth: number) => {
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(path.join(main, relative), { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const child = path.join(relative, entry.name);
+      if (entry.name === MODULES) out.push(child);
+      else if (depth < MAX_DEPTH && !entry.name.startsWith(".")) walk(child, depth + 1);
+    }
+  };
+  walk("", 0);
+  return out;
+}
+
+function linkEntry(main: string, worktree: string, source: string, target: string): void {
+  const stat = fs.lstatSync(source);
+  if (stat.isSymbolicLink()) {
+    const link = fs.readlinkSync(source);
+    // An absolute link into the main checkout (outside its node_modules) is a
+    // workspace package: point it at the worktree's copy.
+    const outside =
+      path.isAbsolute(link) &&
+      within(link, main) &&
+      !path.relative(main, link).split(path.sep).includes(MODULES);
+    const to = outside ? path.join(worktree, path.relative(main, link)) : link;
+    fs.symlinkSync(to, target, process.platform === "win32" ? "junction" : undefined);
+    return;
+  }
+  fs.symlinkSync(
+    source,
+    target,
+    process.platform === "win32" ? (stat.isDirectory() ? "junction" : "file") : undefined,
+  );
+}
+
+/** Mirror `source` into a new directory `target`; returns the links made. */
+function mirror(main: string, worktree: string, source: string, target: string, top: boolean) {
+  fs.mkdirSync(target);
+  let count = 0;
+  for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
+    const from = path.join(source, entry.name);
+    const to = path.join(target, entry.name);
+    if (top && entry.isDirectory() && (entry.name.startsWith("@") || entry.name === ".bin"))
+      count += mirror(main, worktree, from, to, false);
+    else {
+      linkEntry(main, worktree, from, to);
+      count += 1;
+    }
+  }
+  return count;
+}
+
+/**
+ * Give `worktree` node_modules that resolve its own workspace packages and
+ * share the main checkout's installed ones. Null when there is nothing to
+ * link (no node_modules in the main checkout), with a note when it was
+ * skipped; never throws.
+ */
+export function linkWorktreeDependencies(
+  main: string,
+  worktree: string,
+): { linked: LinkedDependencies | null; notes: string[] } {
+  const started = performance.now();
+  const notes: string[] = [];
+  const dirs: string[] = [];
+  let entries = 0;
+  for (const relative of moduleDirs(main)) {
+    const target = path.join(worktree, relative);
+    if (!fs.existsSync(path.dirname(target)) || fs.existsSync(target)) continue;
+    // The trailing slash: the directory does not exist yet, and `node_modules/` only matches one.
+    if (!gitRun(worktree, ["check-ignore", "-q", `${relative.split(path.sep).join("/")}/`]).ok) {
+      notes.push(
+        `${relative.split(path.sep).join("/")} is not ignored by git, so it was not linked from ${main}; install dependencies in the worktree yourself`,
+      );
+      continue;
+    }
+    try {
+      entries += mirror(main, worktree, path.join(main, relative), target, true);
+      dirs.push(relative.split(path.sep).join("/"));
+    } catch (error) {
+      fs.rmSync(target, { recursive: true, force: true });
+      notes.push(
+        `could not link ${relative} from ${main} (${(error as Error).message}); install dependencies in the worktree yourself`,
+      );
+    }
+  }
+  if (dirs.length === 0) return { linked: null, notes };
+  const ms = Math.round(performance.now() - started);
+  notes.push(
+    `linked ${dirs.join(", ")} from ${main} (${entries} entries, ${ms} ms): workspace packages resolve to this worktree, installed packages are shared`,
+  );
+  return { linked: { from: main, dirs, entries, ms }, notes };
+}

package/templates/headers.md

@@ -0,0 +1,3 @@
+## Adjunto capturas
+
+## Archivos adjuntos

package/templates/hygiene/.editorconfig

@@ -0,0 +1,8 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 2

package/templates/hygiene/.gitattributes

@@ -0,0 +1,3 @@
+* text=auto
+*.md text
+*.bat text eol=crlf

package/templates/hygiene/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+### Changed
+
+### Fixed

package/templates/hygiene/CONTRIBUTING.md

@@ -0,0 +1,3 @@
+# Contributing
+
+<!-- How to report issues, propose changes, and the review process. -->

package/templates/hygiene/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) <YEAR> <HOLDER>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/templates/hygiene/README.md

@@ -0,0 +1,3 @@
+# <PROJECT>
+
+<!-- Describe the project: what it does, how to run it, how to contribute. -->

package/templates/issue-update.md

@@ -0,0 +1,5 @@
+# Update
+{{projectSection}}
+{{userNotesSection}}
+{{progressSection}}
+{{gitCommitsSection}}