@jhlee0619/codexloop 0.1.0 → 0.1.3

package/scripts/lib/validate.mjs

@@ -1,8 +1,13 @@
 // Validation runner: executes the user-configured test / lint / type
-// commands and reports exit-code-derived pass/fail plus a simple regression
-// flag relative to the previous iteration.
+// commands AND the built-in validator pipeline, then reports combined
+// pass/fail plus a simple regression flag relative to the previous iteration.
+//
+// v0.2: validator pipeline runs spec.validators + mode-implicit validators
+// from the mode adapter. Each result is stored in record.validatorResults.
+// Overall pass = shell_passed AND all error-severity validators passed.
 
 import { runCommand } from "./process.mjs";
+import { runValidator } from "./validators/registry.mjs";
 
 function tailLines(text, max = 20) {
   if (!text) return "";
@@ -27,7 +32,8 @@ function runShell(cmd, { cwd, timeoutMs = 600_000 }) {
 // Returns a structured record the iteration layer records verbatim.
 // `previousIteration` is the previous iteration summary from state.iterations
 // (undefined on the first iteration).
-export async function runValidation({ cwd, goal, previousIteration }) {
+// `spec` and `implicitValidators` are v0.2 additions for the built-in validator pipeline.
+export async function runValidation({ cwd, goal, previousIteration, spec = null, implicitValidators = [] }) {
   const record = {
     passed: null,
     testsPassed: null,
@@ -36,7 +42,8 @@ export async function runValidation({ cwd, goal, previousIteration }) {
     typeErrors: null,
     lintErrors: null,
     regression: false,
-    commands: []
+    commands: [],
+    validatorResults: []
   };
 
   const test = goal?.testCmd ? runShell(goal.testCmd, { cwd }) : null;
@@ -57,10 +64,34 @@ export async function runValidation({ cwd, goal, previousIteration }) {
     record.typeErrors = typeCheck.status === 0 ? 0 : 1;
   }
 
-  if (record.commands.length === 0) {
+  // ── Built-in validator pipeline (v0.2) ──────────────────────────
+  const validatorEntries = [
+    ...implicitValidators,
+    ...(Array.isArray(spec?.validators) ? spec.validators : [])
+  ];
+  const seenNames = new Set();
+  for (const entry of validatorEntries) {
+    if (!entry.name || seenNames.has(entry.name)) continue;
+    seenNames.add(entry.name);
+    const result = runValidator(entry.name, { cwd, spec, args: entry.args ?? {} });
+    record.validatorResults.push(result);
+  }
+
+  // ── Combined pass logic ────────────────────────────────────────
+  const shellPassed = record.commands.length === 0
+    ? null
+    : record.commands.every((c) => c.status === 0);
+
+  const errorValidatorsFailed = record.validatorResults
+    .filter((r) => r.severity === "error")
+    .some((r) => !r.passed);
+
+  if (shellPassed === null && record.validatorResults.length === 0) {
     record.passed = null;
+  } else if (shellPassed === false || errorValidatorsFailed) {
+    record.passed = false;
   } else {
-    record.passed = record.commands.every((c) => c.status === 0);
+    record.passed = true;
   }
 
   if (previousIteration?.validate?.passed === true && record.passed === false) {

package/scripts/lib/validators/file-exists.mjs

@@ -0,0 +1,35 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export const name = "file_exists";
+
+export function run({ cwd, spec, args }) {
+  const files = args?.files ?? spec?.required_files ?? [];
+  const missing = [];
+  const empty = [];
+  for (const file of files) {
+    const abs = path.resolve(cwd, file);
+    if (!fs.existsSync(abs)) {
+      missing.push(file);
+    } else {
+      const stat = fs.statSync(abs);
+      if (stat.size === 0) {
+        empty.push(file);
+      }
+    }
+  }
+  const issues = [...missing.map((f) => `missing: ${f}`), ...empty.map((f) => `empty: ${f}`)];
+  return {
+    name,
+    passed: issues.length === 0,
+    severity: issues.length > 0 ? "error" : "info",
+    count: issues.length,
+    details: issues.length === 0
+      ? `All ${files.length} required file(s) exist and are non-empty.`
+      : `${issues.length} issue(s): ${issues.join("; ")}`,
+    evidence: [
+      ...missing.map((f) => ({ file: f, line: null, snippet: "file does not exist" })),
+      ...empty.map((f) => ({ file: f, line: null, snippet: "file is empty (0 bytes)" }))
+    ]
+  };
+}

package/scripts/lib/validators/headings-present.mjs

@@ -0,0 +1,44 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export const name = "headings_present";
+
+export function run({ cwd, spec, args }) {
+  const sections = args?.sections ?? spec?.required_sections ?? [];
+  const missing = [];
+
+  for (const entry of sections) {
+    const file = entry.file;
+    const headings = Array.isArray(entry.headings) ? entry.headings : [];
+    const abs = path.resolve(cwd, file);
+    if (!fs.existsSync(abs)) {
+      for (const h of headings) {
+        missing.push({ file, heading: h, reason: "file not found" });
+      }
+      continue;
+    }
+    const content = fs.readFileSync(abs, "utf8");
+    const lines = content.split(/\r?\n/).map((l) => l.trim());
+    for (const h of headings) {
+      const trimmed = h.trim();
+      if (!lines.includes(trimmed)) {
+        missing.push({ file, heading: trimmed, reason: "heading not found" });
+      }
+    }
+  }
+
+  return {
+    name,
+    passed: missing.length === 0,
+    severity: missing.length > 0 ? "error" : "info",
+    count: missing.length,
+    details: missing.length === 0
+      ? "All required headings are present."
+      : `${missing.length} heading(s) missing: ${missing.map((m) => `${m.heading} in ${m.file}`).join("; ")}`,
+    evidence: missing.map((m) => ({
+      file: m.file,
+      line: null,
+      snippet: `${m.reason}: ${m.heading}`
+    }))
+  };
+}

package/scripts/lib/validators/max-placeholder-count.mjs

@@ -0,0 +1,58 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export const name = "max_placeholder_count";
+
+const DEFAULT_PATTERN = /\bTODO\b|\bTBD\b|\bXXX\b|\[placeholder\]/gi;
+const FENCE_OPEN = /^```/;
+const FENCE_CLOSE = /^```$/;
+
+export function run({ cwd, spec, args }) {
+  const max = args?.max ?? spec?.placeholder_policy?.max ?? 10;
+  const customPattern = args?.pattern ? new RegExp(args.pattern, "gi") : null;
+  const pattern = customPattern ?? DEFAULT_PATTERN;
+  const files = args?.files ?? spec?.required_files ?? [];
+
+  const hits = [];
+  for (const file of files) {
+    const abs = path.resolve(cwd, file);
+    if (!fs.existsSync(abs)) continue;
+    const content = fs.readFileSync(abs, "utf8");
+    const lines = content.split(/\r?\n/);
+
+    let inFence = false;
+    for (let i = 0; i < lines.length; i += 1) {
+      const line = lines[i];
+      if (FENCE_OPEN.test(line.trim())) {
+        inFence = !inFence;
+        if (FENCE_CLOSE.test(line.trim()) && inFence) {
+          inFence = true;
+        }
+        continue;
+      }
+      if (inFence) continue;
+
+      pattern.lastIndex = 0;
+      let match;
+      while ((match = pattern.exec(line)) !== null) {
+        hits.push({
+          file,
+          line: i + 1,
+          snippet: line.trim().slice(0, 160)
+        });
+      }
+    }
+  }
+
+  const passed = hits.length <= max;
+  return {
+    name,
+    passed,
+    severity: passed ? (hits.length > 0 ? "warn" : "info") : "error",
+    count: hits.length,
+    details: hits.length === 0
+      ? "No placeholders found."
+      : `${hits.length} placeholder(s) found (max ${max}).${passed ? "" : " EXCEEDS LIMIT."}`,
+    evidence: hits.slice(0, 20)
+  };
+}

package/scripts/lib/validators/registry.mjs

@@ -0,0 +1,47 @@
+// Validator name → run function registry.
+// validate.mjs looks up validators here by name. Each validator is a
+// standalone .mjs file exporting { name, run({ cwd, spec, args }) }.
+
+import { name as fileExistsName, run as fileExistsRun } from "./file-exists.mjs";
+import { name as headingsPresentName, run as headingsPresentRun } from "./headings-present.mjs";
+import { name as maxPlaceholderName, run as maxPlaceholderRun } from "./max-placeholder-count.mjs";
+
+const REGISTRY = {
+  [fileExistsName]: fileExistsRun,
+  [headingsPresentName]: headingsPresentRun,
+  [maxPlaceholderName]: maxPlaceholderRun
+};
+
+export function getValidator(name) {
+  return REGISTRY[name] ?? null;
+}
+
+export function getRegisteredNames() {
+  return Object.keys(REGISTRY);
+}
+
+export function runValidator(name, context) {
+  const fn = getValidator(name);
+  if (!fn) {
+    return {
+      name,
+      passed: false,
+      severity: "error",
+      count: null,
+      details: `Unknown validator: ${name}. Registered: ${getRegisteredNames().join(", ")}`,
+      evidence: []
+    };
+  }
+  try {
+    return fn(context);
+  } catch (err) {
+    return {
+      name,
+      passed: false,
+      severity: "error",
+      count: null,
+      details: `Validator ${name} threw: ${err.message}`,
+      evidence: []
+    };
+  }
+}

package/scripts/loop-companion.mjs

@@ -56,6 +56,8 @@ import {
   VALID_REASONING_EFFORTS,
   writePidFile
 } from "./lib/state.mjs";
+import { loadTaskSpec, autoDetectTaskSpec } from "./lib/task-spec.mjs";
+import { getValidModes } from "./lib/modes/index.mjs";
 import { runIteration } from "./lib/iteration.mjs";
 import { checkCodexAvailable } from "./lib/codex-exec.mjs";
 import { checkStopping } from "./lib/convergence.mjs";
@@ -98,7 +100,8 @@ const USAGE = [
 
 const VALUE_OPTIONS = [
   "goal", "task-file", "max-iter", "max-time", "max-calls",
-  "model", "effort", "nproposals", "test-cmd", "lint-cmd", "type-cmd",
+  "model", "effort", "nproposals", "mode",
+  "test-cmd", "lint-cmd", "type-cmd",
   "cwd", "loop-id", "iteration"
 ];
 const BOOLEAN_OPTIONS = [
@@ -262,13 +265,49 @@ async function handleStart(argv) {
       return 1;
     }
   }
+  // v0.2: task mode + task spec
+  if (options.mode) {
+    const validModes = getValidModes();
+    const lower = String(options.mode).trim().toLowerCase();
+    if (!validModes.includes(lower)) {
+      printError(`Invalid task mode "${options.mode}". Valid: ${validModes.join(", ")}`);
+      return 1;
+    }
+    state.taskMode = lower;
+  }
+
+  // Load task spec: --task-file <path>.json → parse as spec; auto-detect cloop.task.json at repo root
+  if (options["task-file"] && String(options["task-file"]).endsWith(".json")) {
+    try {
+      const specPath = path.resolve(repoRoot, options["task-file"]);
+      const spec = loadTaskSpec(specPath);
+      if (spec) {
+        state.goal.spec = spec;
+        if (spec.mode && !options.mode) {
+          state.taskMode = spec.mode;
+        }
+      }
+    } catch (err) {
+      printError(`Failed to load task spec: ${err.message}`);
+      return 1;
+    }
+  } else if (!options["task-file"]) {
+    const detected = autoDetectTaskSpec(repoRoot);
+    if (detected) {
+      state.goal.spec = detected;
+      if (detected.mode && !options.mode) {
+        state.taskMode = detected.mode;
+      }
+    }
+  }
+
   state.startedAt = nowIso();
   state.goal.text = goalText;
   state.goal.seedCommit = gitHeadSha(repoRoot);
   state.goal.testCmd = options["test-cmd"] ?? null;
   state.goal.lintCmd = options["lint-cmd"] ?? null;
   state.goal.typeCmd = options["type-cmd"] ?? null;
-  state.goal.goalHash = computeGoalHash(state.goal);
+  state.goal.goalHash = computeGoalHash(state.goal, state.taskMode);
 
   if (options["max-iter"]) {
     state.budget.maxIterations = parseInteger(options["max-iter"], {
@@ -295,6 +334,18 @@ async function handleStart(argv) {
   const gi = ensureGitignore(repoRoot);
   if (gi.added) {
     process.stdout.write(`Added .loop/ to ${gi.path}\n`);
+    // Commit the .gitignore change so the working tree is clean for the first
+    // iteration's applyPatch check. handleStart already verified the tree was
+    // clean before this point, so the only dirty file is .gitignore.
+    const commitEnv = {
+      ...process.env,
+      GIT_AUTHOR_NAME: process.env.GIT_AUTHOR_NAME ?? "CodexLoop",
+      GIT_AUTHOR_EMAIL: process.env.GIT_AUTHOR_EMAIL ?? "codexloop@local",
+      GIT_COMMITTER_NAME: process.env.GIT_COMMITTER_NAME ?? "CodexLoop",
+      GIT_COMMITTER_EMAIL: process.env.GIT_COMMITTER_EMAIL ?? "codexloop@local"
+    };
+    runCommand("git", ["add", ".gitignore"], { cwd: repoRoot, env: commitEnv });
+    runCommand("git", ["commit", "-m", "cloop: add .loop/ to .gitignore"], { cwd: repoRoot, env: commitEnv });
   }
   saveState(repoRoot, state);