@agjs/tsforge 0.2.3 → 0.2.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agjs/tsforge",
   "type": "module",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "license": "MIT",
   "description": "TypeScript coding harness with a deterministic gate, stack-aware guardrails, and stream-level correction.",
   "repository": {

package/src/detect-gate.ts

@@ -478,6 +478,47 @@ export function buildCoreFix(): string {
   return `${lintFix} ; ${format}`;
 }
 
+/**
+ * Auto-format ONE just-written file in place: `eslint --fix` (squashes the
+ * auto-fixable mechanical rules — padding-line, curly, prefer-template, quotes)
+ * then `prettier --write` (whitespace/quotes/width). Run at WRITE time (in the
+ * write guard) so the model never sees — nor hand-chases — formatting noise.
+ * Deferring all of this to the settle-time gate let the model self-run eslint
+ * mid-build, see the un-squashed mechanical lint, and spiral fixing blank lines
+ * and braces by hand to the turn cap. Best-effort + per-file (cheap): any failure
+ * is swallowed and the settle gate stays the authority.
+ */
+export async function formatFile(cwd: string, file: string): Promise<void> {
+  const abs = join(cwd, file);
+
+  try {
+    await Bun.spawn(
+      [
+        "bun",
+        ESLINT_BIN,
+        "--no-config-lookup",
+        "-c",
+        STRICT_CONFIG,
+        "--fix",
+        abs,
+      ],
+      { cwd, stdout: "ignore", stderr: "ignore" }
+    ).exited;
+  } catch {
+    // best-effort — the settle gate still fixes + validates
+  }
+
+  try {
+    await Bun.spawn(["bun", PRETTIER_BIN, "--write", abs], {
+      cwd,
+      stdout: "ignore",
+      stderr: "ignore",
+    }).exited;
+  } catch {
+    // best-effort
+  }
+}
+
 async function ensureFile(
   cwd: string,
   name: string,

package/src/files/hashline-format.ts

@@ -108,3 +108,22 @@ export function isValidHash(hash: string): boolean {
 export function normalizeHash(hash: string): string {
   return hash.toUpperCase();
 }
+
+/**
+ * Extract the 4-hex hash from a raw value that may be a full `¶path#HASH` tag,
+ * a `path#HASH`, a `#HASH`, or a bare `HASH`. The model frequently pastes the
+ * whole header tag (what it saw on read) into the `hash` arg, which then fails
+ * the staleness compare against a real 4-hex hash. Returns undefined when no
+ * valid hash is present.
+ */
+export function extractHash(raw: string | undefined): string | undefined {
+  if (raw === undefined) {
+    return undefined;
+  }
+
+  const candidate = raw.includes(HL_HASH_SEP)
+    ? raw.slice(raw.lastIndexOf(HL_HASH_SEP) + 1).trim()
+    : raw.trim();
+
+  return isValidHash(candidate) ? candidate : undefined;
+}

package/src/files/hashline.ts

@@ -10,6 +10,7 @@ import {
   computeFileHash,
   parseHashHeader,
   normalizeHash,
+  HL_HEADER_SIGIL,
 } from "./hashline-format";
 
 /**
@@ -318,26 +319,35 @@ export function parseHashlineEdit(input: string): {
 
   let i = 0;
 
-  // Parse file header
-  if (i < lines.length) {
-    const headerLine = lines[i] ?? "";
-    const parsed = parseHeaderLine(headerLine, errors);
+  // The `¶path#HASH` header is OPTIONAL. The model frequently sends bare ops
+  // (`delete 79..164`) — the path is already in the tool args and the hash
+  // comes from the `hash` arg — so only treat the first line as a header when
+  // it actually looks like one (a malformed sigil header is still an error).
+  const headerLine = lines[0] ?? "";
 
-    filePath = parsed.filePath;
-    fileHash = parsed.fileHash;
+  if (headerLine.startsWith(HL_HEADER_SIGIL)) {
+    const parsed = parseHeaderLine(headerLine, errors);
 
-    if (filePath.length > 0) {
-      i++;
-    } else if (errors.length > 0) {
+    if (errors.length > 0) {
       return { filePath: "", fileHash: undefined, ops: [], errors };
-    } else if (headerLine.trim() === "") {
-      i++;
     }
+
+    filePath = parsed.filePath;
+    fileHash = parsed.fileHash;
+    i = 1;
+  } else if (headerLine.trim() === "") {
+    i = 1;
   }
 
   // Parse operations
   const ops = parseOperations(lines, i, errors);
 
+  if (ops.length === 0 && errors.length === 0) {
+    errors.push(
+      "No edit operations found. Provide replace/delete/insert ops (optionally after a ¶path#HASH header)."
+    );
+  }
+
   return { filePath, fileHash, ops, errors };
 }
 

package/src/loop/prompt/prompt.ts

@@ -11,6 +11,7 @@ export const SYSTEM = [
   "Tools: `read` (inspect a file), `edit` (replace an exact, unique snippet), `create` (a new file), `run` (execute any shell command and see its output).",
   "Lead with action: write the implementation FIRST (one `create`/`edit`) — do NOT deliberate at length before writing any code.",
   "After every edit the harness AUTOMATICALLY runs the gate and gives you the result (the errors + fix guidance for the failing rules). You do NOT need to run the acceptance command yourself — read that result and fix exactly what it reports, then edit again. Keep going until it reports green; the harness ends the task at that point.",
+  "The harness also AUTO-FIXES mechanical formatting on every file you write — blank lines, braces, quotes, semicolons, import order, `prefer-template`. NEVER hand-fix or chase those, and do NOT run `tsc`/`eslint`/the gate yourself to look for them. Fix only what the gate explicitly hands back (`as`/`any`/`!`, `I`-prefix, real type errors), then stop.",
   "Test hypotheses by RUNNING them, never by reasoning them out. Unsure about an edge case, rounding, or ordering (`Math.floor(100/3)`, largest-remainder ties)? `run` a quick `bun -e '…console.log(…)'`, or write a throwaway `scratch/check.ts` importing your impl and `run` it. `scratch/` is yours — the gate ignores it.",
   "The gate is `tsc` strict + eslint with every rule an error, so write TypeScript that satisfies it: interfaces are `I`-prefixed; `===`; no `var`; never the non-null `!` — guard index access (`const x = arr[i]; if (x === undefined) {...}`); no `any` and no `as` — type every parameter (e.g. `.reduce((acc: number, r: number) => …, 0)`); explicit boolean conditions. When the gate flags errors in read-only files (tests/types), they come from your editable file being missing or wrong-shaped and vanish once it's correct — don't edit them.",
 ].join("\n");

package/src/loop/tools/edit-hashline.ts

@@ -3,6 +3,7 @@ import {
   parseHashlineEdit,
   SessionSnapshotStore,
 } from "../../files/hashline";
+import { extractHash } from "../../files/hashline-format";
 import { parseOrRepair, reject, type IToolContext } from "./tool-context";
 import { toHashlineEdit } from "../../agent";
 
@@ -50,11 +51,17 @@ export async function doHashlineEdit(
   // Ensure the store exists on the context
   ctx.snapshotStore ??= new SessionSnapshotStore();
 
+  // Hash source priority: the `¶path#HASH` header the model wrote in `input`
+  // (the format it saw on read), else the `hash` arg — tolerantly extracted so
+  // a pasted full tag (`¶path#HASH`) still yields the bare hash. Using the raw
+  // arg directly caused false stale-anchor rejections on unchanged files.
+  const fileHash = parsed.fileHash ?? extractHash(edit.hash);
+
   const result = await applyHashlineEdit(
     ctx.snapshotStore,
     ctx.cwd,
     edit.file,
-    edit.hash,
+    fileHash,
     parsed.ops
   );
 

package/src/loop/turn.ts

@@ -34,6 +34,7 @@ import {
 import { TsService, type ITsDiagnostic } from "../lsp";
 import type { McpRegistry } from "../mcp";
 import type { FileLinter, IFileLintProblem } from "../detect-gate";
+import { formatFile } from "../detect-gate";
 import {
   buildMetaRuleContext,
   runMetaRules,
@@ -322,6 +323,12 @@ async function writeGuard(
     });
   }
 
+  // Auto-format this file NOW (eslint --fix + prettier) — not at the settle
+  // gate. Otherwise the mechanical lint (blank lines, braces, quotes) sits
+  // unfixed between writes, and when the model self-runs the gate it sees the
+  // noise and hand-chases it to the turn cap. Best-effort; gate stays authority.
+  await formatFile(cwd, file);
+
   tsService.refresh(file);
 
   const typeErrors = tsService