@capagents/forgeqe 0.0.0-stage → 1.0.0

package/src/code/attention.ts

@@ -0,0 +1,214 @@
+import { spawnSync } from "node:child_process"
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs"
+import path from "node:path"
+
+import type { CodeReview } from "../types.ts"
+import { jobChanges, type WorkTree } from "./worktree.ts"
+
+/**
+ * When a coding job ends without a passing, approved test, what it wrote does not stay among the repository's tests,
+ * where it would fail every run, and is not thrown away either: it goes to a needs-attention folder next to the tests,
+ * with a README saying which test case it is for, why it stopped, and how to pick it up.
+ *
+ * - Files the job created are moved there, their relative imports rewritten so they still point at the same modules.
+ * - Edits the job made to files that were committed and unchanged before it are saved as changes.patch and reverted,
+ *   so the repository's existing tests and page objects are as they were. Files the user had already changed are left.
+ * - The folder is kept out of builds and test runs: Playwright's config gets a testIgnore for it, TypeScript files a
+ *   @ts-nocheck line, a Python folder a conftest.py that collects nothing, and files of compiled languages (C#, Java,
+ *   Kotlin) a .txt suffix so the project does not compile them.
+ */
+
+export const ATTENTION_DIR = "needs-attention"
+
+export type AttentionInput = {
+  repo: string
+  tree: WorkTree
+  testFile?: string
+  command?: string
+  caseId?: string
+  title?: string
+  url?: string
+  /** Why the job stopped, in a sentence or two. */
+  why: string
+  /** The end of the last test run's output. */
+  output?: string
+  review?: CodeReview
+}
+
+export type Attention = { dir: string; files: string[]; patch?: string; readme: string }
+
+const git = (repo: string, args: string[]) => spawnSync("git", args, { cwd: repo, encoding: "utf8", maxBuffer: 32 * 1024 * 1024 })
+const posix = (p: string) => p.split(path.sep).join("/")
+const COMPILED = /\.(cs|java|kt|kts|scala|go|rs|swift|vb|fs)$/i
+const SCRIPT = /\.(m|c)?[jt]sx?$/i
+
+function slugOf(s: string): string {
+  return s.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "test"
+}
+
+/** The needs-attention folder for a job: beside the test's folder, one subfolder per test case. */
+export function attentionDir(repo: string, testFile: string | undefined, caseId: string | undefined): string {
+  const base = testFile ? path.dirname(testFile) : "."
+  return posix(path.join(base, ATTENTION_DIR, slugOf(caseId || (testFile ? path.basename(testFile).replace(/\..*$/, "") : "unfinished-test"))))
+}
+
+/** Rewrite a moved script's relative imports so they reach the same modules from its new place. */
+export function rewriteImports(source: string, fromDir: string, toDir: string, moved: Map<string, string>): string {
+  const fix = (spec: string) => {
+    if (!spec.startsWith(".")) return spec
+    const target = path.resolve(fromDir, spec)
+    // Another file this job created, moved alongside: by its new name, in the same folder.
+    for (const [oldAbs, newAbs] of moved) {
+      const stem = oldAbs.replace(/\.(m|c)?[jt]sx?$/i, "")
+      if (target === oldAbs || target === stem) return `./${path.basename(target === oldAbs ? newAbs : newAbs.replace(/\.(m|c)?[jt]sx?$/i, ""))}`
+    }
+    let rel = posix(path.relative(toDir, target))
+    if (!rel.startsWith(".")) rel = `./${rel}`
+    return rel
+  }
+  return source
+    .replace(/(\bfrom\s*|\bimport\s*\(\s*|\brequire\s*\(\s*|^\s*import\s+)(['"])(\.{1,2}\/[^'"]*)\2/gm, (_m, lead: string, q: string, spec: string) => `${lead}${q}${fix(spec)}${q}`)
+}
+
+/** Add testIgnore for the folder to the nearest Playwright config above it; false when there is none to change. */
+export function ignoreInPlaywright(repo: string, dirAbs: string): string | null {
+  let dir = dirAbs
+  while (true) {
+    for (const name of ["playwright.config.ts", "playwright.config.js", "playwright.config.mjs", "playwright.config.cjs"]) {
+      const file = path.join(dir, name)
+      if (!existsSync(file)) continue
+      const text = readFileSync(file, "utf8")
+      if (text.includes(ATTENTION_DIR)) return null
+      const glob = `'**/${ATTENTION_DIR}/**'`
+      let next: string | null = null
+      if (/\btestIgnore\s*:\s*\[/.test(text)) next = text.replace(/\btestIgnore\s*:\s*\[/, (m) => `${m}${glob}, `)
+      else if (/\btestIgnore\s*:/.test(text)) next = null
+      else if (/defineConfig\(\s*\{/.test(text)) next = text.replace(/defineConfig\(\s*\{/, (m) => `${m}\n  testIgnore: [${glob}],`)
+      else if (/module\.exports\s*=\s*\{/.test(text)) next = text.replace(/module\.exports\s*=\s*\{/, (m) => `${m}\n  testIgnore: [${glob}],`)
+      if (!next) return null
+      writeFileSync(file, next)
+      return posix(path.relative(repo, file))
+    }
+    const up = path.dirname(dir)
+    if (up === dir || path.relative(repo, up).startsWith("..")) return null
+    dir = up
+  }
+}
+
+/**
+ * Move what an unfinished job wrote into the needs-attention folder and write its README. Null outside git, where
+ * ForgeQE cannot tell the job's files from the user's, and when the job changed nothing.
+ */
+export function moveToAttention(input: AttentionInput): Attention | null {
+  const { repo, tree } = input
+  const changes = jobChanges(tree)
+  if (!changes?.length) return null
+  const status = new Map<string, string>()
+  const st = git(repo, ["status", "--porcelain=v1", "-z", "-uall", "--no-renames"])
+  for (const rec of st.stdout.split("\0")) if (rec.length > 3) status.set(rec.slice(3), rec.slice(0, 2))
+  const created = changes.filter((rel) => !tree.entries.has(rel) && status.get(rel) === "??" && existsSync(path.join(repo, rel)))
+  const edited = changes.filter((rel) => !tree.entries.has(rel) && status.has(rel) && status.get(rel) !== "??" && existsSync(path.join(repo, rel)))
+  const kept = changes.filter((rel) => tree.entries.has(rel) && existsSync(path.join(repo, rel)))
+  if (!created.length && !edited.length) return null
+
+  const relDir = attentionDir(repo, input.testFile && created.includes(input.testFile) ? input.testFile : created[0] || input.testFile, input.caseId)
+  const dirAbs = path.join(repo, relDir)
+  mkdirSync(dirAbs, { recursive: true })
+
+  // Edits to committed files: kept as a patch, then reverted.
+  let patch: string | undefined
+  if (edited.length) {
+    const diff = git(repo, ["diff", "--no-color", "--", ...edited]).stdout
+    if (diff.trim()) {
+      patch = posix(path.join(relDir, "changes.patch"))
+      writeFileSync(path.join(repo, patch), diff)
+      git(repo, ["checkout", "--", ...edited])
+    }
+  }
+
+  // Created files, flat in the folder, with a suffix when two share a name.
+  const moved = new Map<string, string>()
+  const used = new Set<string>()
+  for (const rel of created) {
+    let name = path.basename(rel)
+    for (let n = 2; used.has(name); n++) name = path.basename(rel).replace(/^([^.]*)/, `$1-${n}`)
+    used.add(name)
+    moved.set(path.join(repo, rel), path.join(dirAbs, name))
+  }
+  const files: string[] = []
+  let python = false
+  for (const [oldAbs, newAbs] of moved) {
+    let text: string | null = null
+    try {
+      text = statSync(oldAbs).size < 2_000_000 ? readFileSync(oldAbs, "utf8") : null
+    } catch {}
+    let target = newAbs
+    if (text !== null && SCRIPT.test(oldAbs)) {
+      text = rewriteImports(text, path.dirname(oldAbs), dirAbs, moved)
+      if (/\.tsx?$/i.test(oldAbs) && !text.startsWith("// @ts-nocheck")) text = `// @ts-nocheck: unfinished test, see README.md in this folder\n${text}`
+    }
+    if (COMPILED.test(oldAbs)) target = `${newAbs}.txt`
+    if (/\.py$/i.test(oldAbs)) python = true
+    if (text !== null) {
+      writeFileSync(target, text)
+      rmSync(oldAbs, { force: true })
+    } else {
+      renameSync(oldAbs, target)
+    }
+    files.push(posix(path.relative(repo, target)))
+  }
+  if (python) writeFileSync(path.join(dirAbs, "conftest.py"), "# Unfinished tests: pytest collects nothing here. See README.md.\ncollect_ignore_glob = [\"*\"]\n")
+  const ignored = [...moved.keys()].some((f) => SCRIPT.test(f)) ? ignoreInPlaywright(repo, dirAbs) : null
+
+  const readme = posix(path.join(relDir, "README.md"))
+  const original = [...moved.keys()].map((f) => posix(path.relative(repo, f)))
+  writeFileSync(
+    path.join(repo, readme),
+    [
+      `# Needs attention: ${input.caseId ? `${input.caseId} ` : ""}${input.title || input.testFile || "unfinished test"}`,
+      "",
+      input.url ? `Test case: ${input.url}` : "",
+      `Written by ForgeQE's coding agent on ${new Date().toISOString().slice(0, 10)}. It did not end with a passing, approved test, so it is kept here, out of the test runs, instead of among the tests.`,
+      "",
+      "## Why it stopped",
+      "",
+      input.why.trim(),
+      ...(input.review && !input.review.approved
+        ? ["", "The reviewer's last verdict:", "", input.review.summary, ...input.review.issues.map((i) => `- ${i.file ? `${i.file}: ` : ""}${i.problem}${i.fix ? ` Fix: ${i.fix}` : ""}`)]
+        : []),
+      ...(input.output?.trim() ? ["", "The end of the last test run:", "", "```", input.output.trim().split("\n").slice(-30).join("\n"), "```"] : []),
+      "",
+      "## What is here",
+      "",
+      ...files.map((f, i) => `- ${path.basename(f)} (was ${original[i]})`),
+      ...(patch ? [`- changes.patch: the job's edits to existing files (${edited.join(", ")}), taken out of them; apply with git apply`] : []),
+      ...(kept.length ? ["", `Also changed, and left in place because they had uncommitted changes before the job: ${kept.join(", ")}.`] : []),
+      "",
+      "## Picking it up",
+      "",
+      `1. Move the files back to where they were${patch ? " and apply changes.patch (git apply)" : ""}.`,
+      `2. Fix what is described above, then run it${input.command ? `: ${input.command}` : "."}`,
+      "3. Or ask ForgeQE to finish it, naming this folder.",
+      "",
+      `This folder is kept out of test runs${ignored ? ` (testIgnore in ${ignored})` : python ? " (conftest.py)" : ""}${files.some((f) => f.endsWith(".txt")) ? "; compiled files have a .txt suffix so the project does not build them" : ""}.`,
+    ]
+      .filter((l, i, all) => l !== "" || all[i - 1] !== "")
+      .join("\n") + "\n",
+  )
+  writeIndex(path.dirname(dirAbs))
+  return { dir: relDir, files, ...(patch ? { patch } : {}), readme }
+}
+
+/** needs-attention/README.md: one line per unfinished test, from each subfolder's README title. */
+function writeIndex(rootAbs: string) {
+  const entries = readdirSync(rootAbs, { withFileTypes: true })
+    .filter((e) => e.isDirectory() && existsSync(path.join(rootAbs, e.name, "README.md")))
+    .map((e) => {
+      const title = readFileSync(path.join(rootAbs, e.name, "README.md"), "utf8").split("\n")[0].replace(/^#\s*Needs attention:\s*/, "")
+      return `- [${e.name}](${e.name}/README.md): ${title}`
+    })
+  writeFileSync(
+    path.join(rootAbs, "README.md"),
+    ["# Tests that need attention", "", "ForgeQE's coding agent wrote these but did not finish them: each folder says why and how to pick it up. They are kept out of test runs.", "", ...entries, ""].join("\n"),
+  )
+}