@agjs/tsforge 0.2.0 → 0.2.2

package/src/eval/score.ts

@@ -20,6 +20,15 @@ export function summarize(records: IRunRecord[]): IVariantSummary[] {
     const sum = (select: (r: IRunRecord) => number): number =>
       list.reduce((acc, r) => acc + select(r), 0);
     const scored = list.filter((r) => r.quality !== undefined);
+    const failureClasses: Record<string, number> = {};
+
+    for (const r of list) {
+      const fc = r.failureClass;
+
+      if (!r.passed && fc !== undefined && fc !== "none") {
+        failureClasses[fc] = (failureClasses[fc] ?? 0) + 1;
+      }
+    }
 
     summaries.push({
       label,
@@ -32,6 +41,7 @@ export function summarize(records: IRunRecord[]): IVariantSummary[] {
         scored.length > 0
           ? scored.reduce((acc, r) => acc + (r.quality ?? 0), 0) / scored.length
           : 0,
+      failureClasses,
     });
   }
 

package/src/loop/loop.types.ts

@@ -32,6 +32,10 @@ export interface ILoopEvent {
   /** For `timing` events: how long the turn took, in milliseconds. */
   ms?: number;
   errors?: number;
+  /** For `validated` events: the failing gate rules/codes (e.g. "TS18048",
+   *  "no-restricted-syntax") — the structured substrate the failure classifier
+   *  reads to tell a type error from a lint rule, not just a count. */
+  rules?: readonly string[];
   passed?: boolean;
   file?: string;
   /** For `create` events: the new file's content (rendered as a code block). */

package/src/loop/turn.ts

@@ -784,6 +784,9 @@ export async function settleGate(
     cycle: turn,
     passed: gatePassed,
     errors: gateErrors.length,
+    // Structured rule/code list (not just a count) so the failure classifier can
+    // tell a type error from a lint rule without re-parsing the gate output.
+    rules: gateErrors.flatMap((e) => (e.rule === undefined ? [] : [e.rule])),
     message: gatePassed
       ? `task ${task.id} · turn ${turn}: GREEN`
       : `task ${task.id} · turn ${turn}: red (${String(gateErrors.length)} error(s))${gateDetail}`,

package/strict.eslint.config.mjs

@@ -12,6 +12,7 @@
 // Rule overrides are loaded via TSFORGE_RULE_OVERRIDES env var (JSON-encoded
 // map of bare rule names to "error" | "warn" | "off").
 import tseslint from "typescript-eslint";
+import stylistic from "@stylistic/eslint-plugin";
 
 // Load stack-aware packs if TSFORGE_PACKS env var is set
 let packConfig = [];
@@ -52,7 +53,10 @@ export default tseslint.config(
   {
     files: ["**/*.ts", "**/*.tsx"],
     languageOptions: { parser: tseslint.parser },
-    plugins: { "@typescript-eslint": tseslint.plugin },
+    plugins: {
+      "@typescript-eslint": tseslint.plugin,
+      "@stylistic": stylistic,
+    },
     rules: {
       // The idioms the model habitually violates — all caught WITHOUT type info.
       "@typescript-eslint/consistent-type-assertions": [
@@ -69,6 +73,25 @@ export default tseslint.config(
       "prefer-const": "error",
       "prefer-template": "error",
       "no-var": "error",
+      // Blank-line discipline — the model rarely gets spacing right, so
+      // eslint --fix + prettier make it free. Uses @stylistic (the rule's
+      // maintained home; the core rule is deprecated and spams usedDeprecatedRules
+      // into eslint's --format json gate output).
+      "@stylistic/padding-line-between-statements": [
+        "error",
+        { blankLine: "always", prev: "import", next: "*" },
+        { blankLine: "any", prev: "import", next: "import" },
+        { blankLine: "always", prev: "*", next: "return" },
+        { blankLine: "always", prev: "*", next: "throw" },
+        { blankLine: "always", prev: ["const", "let", "var"], next: "*" },
+        {
+          blankLine: "any",
+          prev: ["const", "let", "var"],
+          next: ["const", "let", "var"],
+        },
+        { blankLine: "always", prev: "block-like", next: "*" },
+        { blankLine: "always", prev: "*", next: "block-like" },
+      ],
       eqeqeq: ["error", "always"],
       curly: ["error", "all"],
       "no-restricted-syntax": [

package/strict.type-aware.eslint.config.mjs

@@ -0,0 +1,33 @@
+// Optional type-aware ESLint overlay — enabled only when the target has a
+// compiling tsconfig (see detect-gate.ts). Adds async correctness rules that
+// require parserOptions.project; kept separate from strict.eslint.config.mjs
+// so the syntactic gate still runs on any .ts file without type info.
+import tseslint from "typescript-eslint";
+
+export default tseslint.config(
+  { ignores: ["**/node_modules/**", "**/dist/**", "**/build/**"] },
+  {
+    files: ["**/*.ts", "**/*.tsx"],
+    languageOptions: {
+      parser: tseslint.parser,
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: process.cwd(),
+      },
+    },
+    plugins: {
+      "@typescript-eslint": tseslint.plugin,
+    },
+    rules: {
+      "@typescript-eslint/no-floating-promises": "error",
+      "@typescript-eslint/no-misused-promises": [
+        "error",
+        {
+          checksVoidReturn: {
+            attributes: false,
+          },
+        },
+      ],
+    },
+  }
+);