ltcai 11.2.0 → 11.4.0

package/scripts/check_max_file_lines.mjs

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+// Max file length gate (11.3.0): no first-party source file over 1,000 lines.
+//
+// Why a gate and not a habit: `frontend/src/styles.css` reached 10,956 lines and
+// twenty-seven other files passed 1,000 before anyone noticed. Long files are
+// not a style opinion here — they are slow to review, they burn an agent's
+// context on the 90% of the file that is irrelevant to the change, and two
+// people editing different features of the same file conflict every time.
+//
+// The rule: every git-tracked *.py *.ts *.tsx *.js *.mjs *.cjs *.css *.rs file —
+// tests included — stays at or under 1,000 lines. Split by cohesion, not by
+// cutting at line 1,000: a module that needs more than a thousand lines is doing
+// more than one job.
+//
+// Exit 0 clean, 1 when a file is over the limit, 2 when the check cannot run.
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import process from "node:process";
+
+const repo = join(import.meta.dirname, "..");
+
+const MAX_LINES = 1000;
+
+// `*.rs` joined in 11.4.0 with the Rust foundation (rust/ workspace +
+// src-tauri). Build output — rust/target, src-tauri/target — is gitignored and
+// therefore never listed here in the first place.
+const EXTENSIONS = ["*.py", "*.ts", "*.tsx", "*.js", "*.mjs", "*.cjs", "*.css", "*.rs"];
+
+// Paths that are not written by hand. Each entry names why it is here; nothing
+// gets added to this list to make a hand-written file pass.
+const EXCLUDED = [
+  // Generated from the OpenAPI schema by `npm run frontend:openapi`.
+  "frontend/src/api/openapi.ts",
+  // Vite build output. Editing it by hand is already a mistake (v10.1.1).
+  "static/app/",
+  // Third-party libraries shipped as-is.
+  "static/vendor/",
+  // Tauri's generated platform scaffolding.
+  "src-tauri/gen/",
+];
+
+function isExcluded(file) {
+  return EXCLUDED.some((prefix) =>
+    prefix.endsWith("/") ? file.startsWith(prefix) : file === prefix,
+  );
+}
+
+/** `wc -l` semantics: how many newline-terminated lines the file holds. */
+function lineCount(file) {
+  const text = readFileSync(join(repo, file), "utf8");
+  if (!text) return 0;
+  const parts = text.split("\n");
+  return text.endsWith("\n") ? parts.length - 1 : parts.length;
+}
+
+// `--others --exclude-standard` adds files that exist but are not committed yet
+// while still honouring .gitignore. Without it a brand-new 3,000-line module
+// passes the gate on the branch that introduces it and only fails after the
+// commit that was supposed to be reviewed against it.
+let tracked;
+try {
+  const listed = execFileSync(
+    "git",
+    ["ls-files", "--cached", "--others", "--exclude-standard", "--", ...EXTENSIONS],
+    { cwd: repo, encoding: "utf8", maxBuffer: 32 * 1024 * 1024 },
+  );
+  tracked = [...new Set(listed.split("\n").map((line) => line.trim()).filter(Boolean))];
+} catch (error) {
+  console.error(`max file lines: could not list tracked files (${error.message})`);
+  process.exit(2);
+}
+
+const oversized = [];
+for (const file of tracked) {
+  if (isExcluded(file)) continue;
+  let lines;
+  try {
+    lines = lineCount(file);
+  } catch {
+    // A tracked path that is not readable (deleted in the working tree, a
+    // submodule pointer) is not this gate's business.
+    continue;
+  }
+  if (lines > MAX_LINES) oversized.push({ file, lines });
+}
+
+if (oversized.length) {
+  oversized.sort((a, b) => b.lines - a.lines);
+  console.error(
+    `max file lines: ${oversized.length} file(s) over ${MAX_LINES} lines.\n` +
+      oversized.map(({ file, lines }) => `  ${String(lines).padStart(6)}  ${file}`).join("\n") +
+      "\n\n  Split each into cohesive modules (target ≤700 lines) and re-run.\n" +
+      "  Generated or vendored output belongs in the EXCLUDED list in\n" +
+      "  scripts/check_max_file_lines.mjs, with a comment saying why.",
+  );
+  process.exit(1);
+}
+
+console.log(
+  `max file lines ok: ${tracked.length} tracked file(s) scanned, none over ${MAX_LINES} lines`,
+);

package/scripts/check_release_evidence_bound.mjs

@@ -9,14 +9,18 @@
  * 3. The pre-capture guard only compares frontend/src mtime vs manifest mtime,
  *    so it still passes — while screenshots show an older UI than the build.
  *
- * Also: capture hits tests/visual/mock_server.cjs for API payloads. Changing
- * the mock after capture (e.g. taller Act panel → 1846px vs committed 1721px)
- * left asset-manifest.sha256 alone, so this gate used to stay green while
+ * Also: capture hits the visual mock server for API payloads. Changing the mock
+ * after capture (e.g. taller Act panel → 1846px vs committed 1721px) left
+ * asset-manifest.sha256 alone, so this gate used to stay green while
  * SCREENSHOT_INDEX.md described a UI the tree no longer produces.
  *
+ * The mock server is an entry file plus the route modules it composes, and the
+ * fingerprint covers all of them — see scripts/lib/mock_server_fingerprint.mjs,
+ * shared with capture so the recorded and the checked digest cannot drift.
+ *
  * Capture records asset-manifest.sha256 and mock-server.sha256 in
  * SCREENSHOT_INDEX.md. This script fails (exit 1) when either binding is
- * missing or does not match the live file. Wired into `npm run lint` so a
+ * missing or does not match the live files. Wired into `npm run lint` so a
  * green lint cannot ship stale screenshots.
  *
  * Exit 0 bound, 1 stale/missing, 2 could not run.
@@ -28,6 +32,12 @@ import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 
+import {
+  MOCK_SERVER_ENTRY,
+  MOCK_SERVER_LABEL,
+  mockServerFingerprint,
+} from "./lib/mock_server_fingerprint.mjs";
+
 const repoRoot = process.cwd();
 
 if (process.env.LTCAI_SKIP_RELEASE_EVIDENCE_BOUND === "1") {
@@ -43,7 +53,6 @@ const root =
   path.join(repoRoot, "output", "release", `v${version}`);
 const indexPath = path.join(root, "SCREENSHOT_INDEX.md");
 const manifestPath = path.join(repoRoot, "static", "app", "asset-manifest.json");
-const mockServerPath = path.join(repoRoot, "tests", "visual", "mock_server.cjs");
 
 function fail(message, code = 1) {
   console.error(message);
@@ -60,8 +69,9 @@ if (!fs.existsSync(indexPath)) {
 if (!fs.existsSync(manifestPath)) {
   fail("release evidence binding: static/app/asset-manifest.json missing", 2);
 }
-if (!fs.existsSync(mockServerPath)) {
-  fail("release evidence binding: tests/visual/mock_server.cjs missing", 2);
+const mockFp = mockServerFingerprint(repoRoot);
+if (!mockFp) {
+  fail(`release evidence binding: ${MOCK_SERVER_ENTRY} missing`, 2);
 }
 
 const index = fs.readFileSync(indexPath, "utf8");
@@ -77,7 +87,7 @@ const mockMatch = index.match(/mock-server\.sha256:\s*`?([0-9a-f]{64})`?/i);
 if (!mockMatch) {
   fail(
     "release evidence binding: SCREENSHOT_INDEX.md has no mock-server.sha256.\n" +
-      "  Capture data comes from tests/visual/mock_server.cjs; re-run\n" +
+      `  Capture data comes from ${MOCK_SERVER_LABEL}; re-run\n` +
       "  npm run release:evidence so the index records the mock fingerprint.",
   );
 }
@@ -97,20 +107,25 @@ if (recorded !== current) {
 }
 
 const recordedMock = mockMatch[1].toLowerCase();
-const currentMock = sha256File(mockServerPath);
-const mockMtime = fs.statSync(mockServerPath).mtime.toISOString();
+const currentMock = mockFp.sha256;
 
 if (recordedMock !== currentMock) {
   fail(
-    "release evidence binding: screenshots are stale relative to mock_server.cjs.\n" +
+    "release evidence binding: the mock server changed since capture.\n" +
       `  recorded mock-server.sha256: ${recordedMock}\n` +
       `  current  mock-server.sha256: ${currentMock}\n` +
-      `  current  mtime:  ${mockMtime}\n` +
-      "  Mock API payloads changed after capture. Run: npm run release:evidence\n" +
-      "  (bump version first if vX.Y.Z is already tagged — see docs/OPERATIONS.md).",
+      `  covers:  ${MOCK_SERVER_LABEL} (${mockFp.files} file(s), ${mockFp.bytes} bytes)\n` +
+      `  newest   mtime:  ${mockFp.mtime}\n` +
+      "  Mock API payloads changed after capture, so the screenshots may show\n" +
+      "  responses the tree no longer produces. Re-capture the evidence:\n" +
+      "    npm run release:evidence\n" +
+      "  (bump version first if vX.Y.Z is already tagged — see docs/OPERATIONS.md).\n" +
+      "  v11.3.0 widened this fingerprint from the entry file alone to the entry\n" +
+      "  plus its route modules, so an evidence set captured before v11.3.0\n" +
+      "  reports a mismatch until it is re-captured.",
   );
 }
 
 console.log(
-  `release evidence binding ok: asset=${current.slice(0, 12)}… mock=${currentMock.slice(0, 12)}… mtime=${mtime} dir=${path.relative(repoRoot, root)}`,
+  `release evidence binding ok: asset=${current.slice(0, 12)}… mock=${currentMock.slice(0, 12)}… (${mockFp.files} mock file(s)) mtime=${mtime} dir=${path.relative(repoRoot, root)}`,
 );

package/scripts/check_screenshot_pixel_delta.py

@@ -45,6 +45,7 @@ SHOTS = [
     "10-admin-console.png",
     "11-knowledge-journey.png",
     "12-review-center.png",
+    "13-chronicle.png",
 ]
 
 # LivingBrain animation noise can hit ~7.9% with zero layout change.
@@ -183,11 +184,10 @@ def _extract_baseline_from_git(root: Path, version: str) -> Optional[Path]:
 
     cache = root / "output" / ".cache" / "screenshot-baseline" / f"v{version}" / "screenshots"
     cache.mkdir(parents=True, exist_ok=True)
-    extracted = 0
+    missing: List[str] = []
     for name in SHOTS:
         dest = cache / name
         if dest.is_file() and dest.stat().st_size > 0:
-            extracted += 1
             continue
         git_path = f"output/release/v{version}/screenshots/{name}"
         result = subprocess.run(
@@ -197,11 +197,19 @@ def _extract_baseline_from_git(root: Path, version: str) -> Optional[Path]:
             check=False,
         )
         if result.returncode != 0 or not result.stdout:
+            missing.append(name)
             continue
         dest.write_bytes(result.stdout)
-        extracted += 1
-    if extracted < len(SHOTS):
+    # A screen the baseline release never captured is a screen introduced by
+    # the current release (the comparison loop reports it as "new" and does
+    # not gate it). Only a baseline with no core capture at all is broken.
+    if "01-login.png" in missing:
         return None
+    if missing:
+        print(
+            f"pixel delta: baseline v{version} lacks {len(missing)} screen(s) "
+            f"introduced later: {', '.join(missing)}"
+        )
     return cache
 
 
@@ -450,6 +458,28 @@ def main(argv: Optional[List[str]] = None) -> int:
             print(f"{name:<32} {'—':>8} {'—':>6} {'—':>6} FAIL")
             continue
         if not base.is_file():
+            # No baseline image: either the screen is new this release
+            # (legitimate — nothing to diff against, report and move on) or a
+            # claim names a screen the baseline should have had (a typo — the
+            # claim gate must fail loudly rather than skip it).
+            if claims is not None and name not in claims:
+                print(f"{name:<32} {'new':>8} {'—':>6} {'—':>6} {'—':>5} (no baseline)")
+                results.append(
+                    {
+                        "file": name,
+                        "pixel_pct": None,
+                        "height_current": None,
+                        "height_baseline": None,
+                        "height_delta": None,
+                        "min_pct": None,
+                        "living_brain": name in LIVING_BRAIN,
+                        "region": None,
+                        "claimed": False,
+                        "moved": None,
+                        "pass": True,
+                    }
+                )
+                continue
             failures.append(f"{name}: missing in baseline")
             print(f"{name:<32} {'—':>8} {'—':>6} {'—':>6} FAIL")
             continue

package/scripts/check_server_i18n.mjs

@@ -34,6 +34,7 @@ const LOCALIZED = [
   "chat",
   "chat_history",
   "chat_intents",
+  "chronicle",
   "features",
   "knowledge_graph",
   "local_files",