@homeflare/config 0.10.0 → 0.11.1

package/src/hooks.ts

@@ -6,43 +6,59 @@
  *   notices, and two repos disagree about what a commit must satisfy. Here the repo
  *   commits a delegating wrapper and the behaviour ships with the package, so changing
  *   the rule is one release and a version bump rather than fourteen edits.
- *
- * ⚠️ HUSKY, NOT lefthook OR A BARE `core.hooksPath`. It is already the estate's
- *   mechanism in the repos that have working hooks, it installs from `prepare` on a
- *   plain `bun install`, and it keeps the hook files tracked and reviewable. A second
- *   mechanism alongside it would mean two ways to answer "are hooks on in this repo".
+ * ★ TRACKED `.husky/`, RUN BY GIT THROUGH `core.hooksPath` — NOT husky's `.husky/_`. Since
+ *   2026-09-23 the mechanism is the one that reaches every worktree; activate.ts has the
+ *   measurement. The files keep the directory name the estate already uses.
+ * ★ PRE-PUSH IS SCOPED TO THE PUSH (push-range.ts, push-plan.ts): the repository's own
+ *   `check`, with `bun test` narrowed to the tests the pushed files can reach and the build
+ *   and smoke test left to CI. Many agents push to many repositories at once; a pre-push
+ *   that re-ran every suite was the one people learned to skip.
  *
  * Usage from a hook file — see `HUSKY_HOOK`:
  *
  *     bun node_modules/@homeflare/config/bin/hooks.ts pre-commit
  */
+import { activateHooks } from './hooks/activate.ts';
 import { preCommit, prePush } from './hooks/gates.ts';
-import { HOOK_NAMES, HUSKY_HOOK, installHooks, problemsInHooks } from './hooks/install.ts';
+import { HOOK_NAMES, HUSKY_HOOK, PREPARE, installHooks, problemsInHooks } from './hooks/install.ts';
+import { type Lane, planLanes } from './hooks/push-plan.ts';
 import { type Hook, note, ok } from './hooks/report.ts';
 
-export { HOOK_NAMES, HUSKY_HOOK, installHooks, problemsInHooks };
-export type { Hook };
+export { HOOK_NAMES, HUSKY_HOOK, PREPARE, activateHooks, installHooks, planLanes, problemsInHooks };
+export type { Hook, Lane };
 
 /** The commands `bin/hooks.ts` accepts. */
-export type Command = Hook | 'install';
+export type Command = Hook | 'install' | 'activate';
 
 export function isCommand(value: string): value is Command {
-  return value === 'pre-commit' || value === 'pre-push' || value === 'install';
+  return ['pre-commit', 'pre-push', 'install', 'activate'].includes(value);
 }
 
 /**
- * Run one hook, or install the wrappers.
+ * Run one hook, write the wrappers, or activate them.
  *
+ * `args` are git's own hook arguments (for `pre-push`: the remote name and URL) and
+ * `stdin` is what git wrote to the hook (for `pre-push`: the refs being pushed).
  * ⛔ Never exits non-zero for a reason the caller cannot act on: an unknown command is a
  *   programming error in the wrapper and is reported as such, not as a failed commit.
  */
-export async function runCommand(command: Command, root: string): Promise<void> {
+export async function runCommand(
+  command: Command,
+  root: string,
+  args: readonly string[] = [],
+  stdin = '',
+): Promise<void> {
   if (command === 'install') {
     const written = await installHooks(root);
     ok(`wrote ${written.join(', ')} — commit them`);
-    note('they do nothing until `bun install` runs `prepare` (husky)');
+    note(`then set "prepare": "${PREPARE}" so every install activates them`);
+    return;
+  }
+  if (command === 'activate') {
+    const result = await activateHooks(root);
+    (result.active ? ok : note)(`homeflare hooks: ${result.message}`);
     return;
   }
   if (command === 'pre-commit') return await preCommit(root);
-  return await prePush(root);
+  return await prePush(root, args, stdin);
 }

package/src/repo-shape/yaml.ts

@@ -6,9 +6,15 @@
  *   this house are the product. The rendered workflows are written as text with holes;
  *   only the step lists, whose shape varies per repository, go through here.
  *
- * ⚠️ Bun can PARSE YAML natively (`Bun.YAML.parse`) but does not stringify it, measured
- *   against Bun 1.4.0 on 2026-09-22. The tests parse what this writes with `Bun.YAML.parse`
- *   and compare structures, so a malformed emission fails rather than shipping.
+ * ⚠️ Bun.YAML.stringify EXISTS (`Object.keys(Bun.YAML)` is `["parse", "stringify"]`,
+ *   measured against Bun 1.4.0 on 2026-09-23) but its output does not fit these rules:
+ *   (a) a multi-line `run:` comes out as a double-quoted string with `\n` escapes, e.g.
+ *   `run: "echo a\necho b\n"`, not a `|` block scalar; (b) `09:00` comes out UNQUOTED,
+ *   e.g. `cron: 09:00`, the YAML 1.1 sexagesimal trap the `scalar()` comment below guards
+ *   against; (c) a mapping key is followed by a trailing space, e.g. `"steps: \n  - ..."`;
+ *   and (d) a plain JS object has nowhere to attach a comment, so it cannot carry one. The
+ *   tests parse what this writes with `Bun.YAML.parse` and compare structures, so a
+ *   malformed emission fails rather than shipping.
  */
 import type { JobStep } from './shape.ts';
 
@@ -53,13 +59,29 @@ function renderMapping(
   return Object.entries(entries).map(([key, value]) => `${indent(depth)}${key}: ${scalar(value)}`);
 }
 
+/**
+ * Trim trailing `\n` characters the way `command.replace(/\n+$/, '')` used to, but
+ * linear instead of backtracking — the same pattern as `normalizeBaseUrl` in
+ * `packages/distilled-netbox/src/credentials.ts`. Exported so a test can compare it
+ * against the old regex directly.
+ *
+ * ⚠️ Linear on purpose: a `/\n+$/` regex backtracks polynomially on a long run of
+ *   "\n" that is not at the end (CodeQL js/polynomial-redos), and `command` here is
+ *   repository-configured step text.
+ */
+export function trimTrailingNewlines(value: string): string {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 10) end--;
+  return value.slice(0, end);
+}
+
 /**
  * ★ BLOCK SCALAR FOR EVERY MULTI-LINE `run:`. A folded or quoted form would join the
  *   lines, and a shell script whose `if` and `then` end up on one line is a syntax error
  *   at job time rather than at lint time. `|` keeps them exactly as written.
  */
 function renderRun(command: string, depth: number): string[] {
-  const lines = command.replace(/\n+$/, '').split('\n');
+  const lines = trimTrailingNewlines(command).split('\n');
   if (lines.length === 1) return [`${indent(depth)}run: ${scalar(lines[0] ?? '')}`];
   return [`${indent(depth)}run: |`, ...lines.map((line) => `${indent(depth + 1)}${line}`)];
 }