@tech-leads-club/harness-toolkit 0.16.5 → 0.16.7

package/src/platform/git.ts

@@ -1,4 +1,14 @@
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  utimesSync,
+  writeFileSync,
+} from "node:fs";
 import { realpath } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
@@ -58,6 +68,52 @@ export async function gitCommonDirOf(dir: string): Promise<string | null> {
   }
 }
 
+export async function workingTreeId(dir: string): Promise<string | null> {
+  let indexPath: string;
+  let objectsPath: string;
+  try {
+    const located = await runProcess({
+      command: ["git", "rev-parse", "--path-format=absolute", "--git-path", "index", "--git-path", "objects"],
+      cwd: dir,
+    });
+    const [index, objects] = located.stdout.trim().split("\n");
+    if (located.exitCode !== 0 || !index || !objects) {
+      return null;
+    }
+    indexPath = index;
+    objectsPath = objects;
+  } catch {
+    return null;
+  }
+  const scratch = mkdtempSync(join(tmpdir(), "tlc-tree-"));
+  const env = {
+    ...process.env,
+    GIT_INDEX_FILE: join(scratch, "index"),
+    GIT_OBJECT_DIRECTORY: join(scratch, "objects"),
+    GIT_ALTERNATE_OBJECT_DIRECTORIES: objectsPath,
+  };
+  const git = (args: string[]) =>
+    runProcess({ command: ["git", "-c", "core.fsmonitor=false", ...args], cwd: dir, env });
+  try {
+    mkdirSync(env.GIT_OBJECT_DIRECTORY);
+    if (existsSync(indexPath)) {
+      copyFileSync(indexPath, env.GIT_INDEX_FILE);
+      const original = statSync(indexPath);
+      utimesSync(env.GIT_INDEX_FILE, original.atime, original.mtime);
+    } else if ((await git(["read-tree", "--empty"])).exitCode !== 0) {
+      return null;
+    }
+    await git(["add", "-A", "--ignore-errors"]);
+    const tree = await git(["write-tree"]);
+    const id = tree.stdout.trim();
+    return tree.exitCode === 0 && id.length > 0 ? id : null;
+  } catch {
+    return null;
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+}
+
 export function linkedWorktreeMainRoot(root: string): string | null {
   let text: string;
   try {

package/src/platform/process.ts

@@ -52,16 +52,18 @@ export async function runProcess(args: {
   input?: string;
   env?: NodeJS.ProcessEnv;
   timeoutMs?: number;
-}): Promise<{ exitCode: number; stdout: string; stderr: string }> {
+}): Promise<{ exitCode: number; stdout: string; stderr: string; timedOut?: boolean }> {
   const [file, ...argv] = args.command;
   if (file === undefined) {
     return { exitCode: 0, stdout: "", stderr: "" };
   }
+  const ownGroup = args.timeoutMs !== undefined && process.platform !== "win32";
   return await new Promise((resolve, reject) => {
     const child = spawn(file, argv, {
       cwd: args.cwd,
       stdio: ["pipe", "pipe", "pipe"] as const,
       env: args.env ?? process.env,
+      detached: ownGroup,
     });
     let stdout = "";
     let stderr = "";
@@ -71,6 +73,12 @@ export async function runProcess(args: {
         ? undefined
         : setTimeout(() => {
             timedOut = true;
+            try {
+              if (ownGroup && child.pid !== undefined) {
+                process.kill(-child.pid, "SIGKILL");
+                return;
+              }
+            } catch {}
             child.kill("SIGKILL");
           }, args.timeoutMs);
 
@@ -87,7 +95,12 @@ export async function runProcess(args: {
     child.on("close", (code) => {
       if (timer) clearTimeout(timer);
       if (timedOut) {
-        resolve({ exitCode: TIMEOUT_EXIT_CODE, stdout, stderr: `${stderr}\n(process timed out)` });
+        resolve({
+          exitCode: TIMEOUT_EXIT_CODE,
+          stdout,
+          stderr: `${stderr}\n(process timed out)`,
+          timedOut: true,
+        });
         return;
       }
       resolve({ exitCode: code ?? 1, stdout, stderr });
@@ -99,7 +112,7 @@ export async function runProcess(args: {
   });
 }
 
-export type CommandResult = { exitCode: number; output: string; durationMs: number };
+export type CommandResult = { exitCode: number; output: string; durationMs: number; timedOut?: boolean };
 
 export const NO_OUTPUT_CAPTURED = "(no output captured)";
 
@@ -114,7 +127,7 @@ export async function runCommand(
   projectDir: string,
   command: string[],
   extraArgs: string[] = [],
-  options: { env?: NodeJS.ProcessEnv } = {},
+  options: { env?: NodeJS.ProcessEnv; timeoutMs?: number } = {},
 ): Promise<CommandResult> {
   if (command.length === 0) {
     return { exitCode: 0, output: "", durationMs: 0 };
@@ -124,6 +137,7 @@ export async function runCommand(
     command: [...command, ...extraArgs],
     cwd: projectDir,
     env: options.env ? { ...process.env, ...options.env } : process.env,
+    ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),
   });
   const combined = (result.stdout + result.stderr).trim();
   const output = combined.length === 0 ? NO_OUTPUT_CAPTURED : combined;
@@ -131,5 +145,6 @@ export async function runCommand(
     exitCode: result.exitCode,
     output,
     durationMs: Date.now() - started,
+    ...(result.timedOut ? { timedOut: true } : {}),
   };
 }

package/tools/verify.ts

@@ -0,0 +1,154 @@
+import { spawn } from "node:child_process";
+import { coreFacade } from "../src/core/index.ts";
+import { emitJson, takeJsonFlag } from "../src/platform/cli-output.ts";
+import { gitRootOf, workingTreeId } from "../src/platform/git.ts";
+import { findProjectRoot } from "../src/platform/paths.ts";
+
+const OUTPUT_KEEP_CHARS = 64 * 1024;
+
+export type VerifyGate = { gate: string; command: string[] };
+
+export type VerifyOutcome = {
+  gate: string;
+  command: string[];
+  exitCode: number;
+  durationMs: number;
+  recorded: boolean;
+  treeChanged: boolean;
+  unidentified: boolean;
+};
+
+export function gatesToVerify(policy: ReturnType<typeof coreFacade.policy.loadPolicy>): VerifyGate[] {
+  const gates: VerifyGate[] = [];
+  if (policy.grind.enabled && policy.grind.lintCommand && policy.grind.lintCommand.length > 0) {
+    gates.push({ gate: "lint", command: policy.grind.lintCommand });
+  }
+  if (policy.grind.enabled && policy.grind.testCommand && policy.grind.testCommand.length > 0) {
+    gates.push({ gate: "test", command: policy.grind.testCommand });
+  }
+  if (policy.docs.command && policy.docs.command.length > 0 && policy.docs.severity === "deny") {
+    gates.push({ gate: "docs", command: policy.docs.command });
+  }
+  return gates;
+}
+
+function runStreaming(
+  command: string[],
+  cwd: string,
+  echo: boolean,
+): Promise<{ exitCode: number; output: string; durationMs: number }> {
+  const started = Date.now();
+  const [file, ...args] = command;
+  return new Promise((resolve) => {
+    let output = "";
+    const keep = (chunk: Buffer, sink: NodeJS.WriteStream) => {
+      if (echo) {
+        sink.write(chunk);
+      }
+      output = (output + chunk.toString("utf8")).slice(-OUTPUT_KEEP_CHARS);
+    };
+    const child = spawn(file ?? "", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    child.stdout.on("data", (chunk: Buffer) => keep(chunk, process.stdout));
+    child.stderr.on("data", (chunk: Buffer) => keep(chunk, process.stderr));
+    child.on("error", (error) => {
+      resolve({ exitCode: 127, output: `${output}\n${error.message}`, durationMs: Date.now() - started });
+    });
+    child.on("close", (code) => {
+      resolve({ exitCode: code ?? 1, output, durationMs: Date.now() - started });
+    });
+  });
+}
+
+export async function verify(args: {
+  root: string;
+  cwd: string;
+  gates: VerifyGate[];
+  echo?: boolean;
+  log?: (line: string) => void;
+}): Promise<{ tree: string | null; outcomes: VerifyOutcome[] }> {
+  const log = args.log ?? ((line: string) => console.log(line));
+  const gitRoot = (await gitRootOf(args.cwd)) ?? args.cwd;
+  const outcomes: VerifyOutcome[] = [];
+  let tree = await workingTreeId(gitRoot);
+  for (const { gate, command } of args.gates) {
+    const before = tree;
+    log(`▸ ${gate}: ${command.join(" ")}`);
+    const result = await runStreaming(command, gitRoot, args.echo ?? true);
+    tree = await workingTreeId(gitRoot);
+    const unidentified = before === null || tree === null;
+    const treeChanged = !unidentified && tree !== before;
+    if (!unidentified && !treeChanged && before !== null) {
+      await coreFacade.gate.recordShipVerdict(args.root, {
+        gate,
+        command,
+        tree: before,
+        exitCode: result.exitCode,
+        durationMs: result.durationMs,
+        output: result.output,
+        source: coreFacade.gate.VERIFY_SOURCE,
+      });
+    }
+    outcomes.push({
+      gate,
+      command,
+      exitCode: result.exitCode,
+      durationMs: result.durationMs,
+      recorded: !unidentified && !treeChanged,
+      treeChanged,
+      unidentified,
+    });
+    log(
+      `${result.exitCode === 0 ? "✔" : "✖"} ${gate} — exit ${result.exitCode} in ${Math.round(result.durationMs / 1000)}s`,
+    );
+    if (result.exitCode !== 0) {
+      break;
+    }
+  }
+  return { tree, outcomes };
+}
+
+export async function main(argv: string[]): Promise<void> {
+  const { json } = takeJsonFlag(argv);
+  const root = process.env.TLC_PROJECT_DIR ?? findProjectRoot(process.cwd()) ?? process.cwd();
+  const policy = coreFacade.policy.loadPolicy(root);
+  const gates = gatesToVerify(policy);
+  if (gates.length === 0) {
+    const message = "verify: no lint, test or docs gate is configured — nothing to verify";
+    if (json) {
+      emitJson({ tree: null, outcomes: [], message });
+    } else {
+      console.log(message);
+    }
+    return;
+  }
+  const { tree, outcomes } = await verify({
+    root,
+    cwd: process.cwd(),
+    gates,
+    echo: !json,
+    ...(json ? { log: (line: string) => console.error(line) } : {}),
+  });
+  const failed = outcomes.find((outcome) => outcome.exitCode !== 0);
+  const changed = outcomes.find((outcome) => outcome.treeChanged);
+  const unidentified = outcomes.find((outcome) => outcome.unidentified);
+  if (json) {
+    emitJson({ tree, outcomes });
+  } else if (failed) {
+    console.log(`verify: ${failed.gate} failed — fix it and run \`tlc harness verify\` again`);
+  } else if (unidentified) {
+    console.log(
+      "verify: git could not identify the working tree, so no verdict was recorded — run `git status` to see what it cannot read",
+    );
+  } else if (changed) {
+    console.log(
+      `verify: ${changed.gate} changed files while it ran, so its result describes a tree that no longer exists — review the changes and run \`tlc harness verify\` again`,
+    );
+  } else {
+    console.log(`verify: all gates passed for tree ${tree?.slice(0, 12)} — commit, push and PR may proceed`);
+  }
+  process.exit(failed || changed || unidentified ? 1 : 0);
+}
+
+if (import.meta.main) {
+  await main(process.argv.slice(2));
+}