@holdpoint/cli 0.1.0-alpha.0

package/dist/index.js

@@ -0,0 +1,995 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync, copyFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+import ora from "ora";
+import { buildHookJson, buildCheckScript, buildConfigJson } from "@holdpoint/engine-copilot";
+import { buildEngineJson as buildClaudeEngineJson } from "@holdpoint/engine-claude";
+import { buildEngine as buildCursorEngine } from "@holdpoint/engine-cursor";
+import { parseHoldpointYaml } from "@holdpoint/yaml-core";
+
+// src/detect.ts
+import { existsSync } from "fs";
+function detectAgent() {
+  if (existsSync(".github/extensions")) return "copilot";
+  if (existsSync(".claude")) return "claude";
+  if (existsSync(".cursorrules")) return "cursor";
+  return "unknown";
+}
+function detectStack() {
+  const hasNext = existsSync("next.config.ts") || existsSync("next.config.js") || existsSync("next.config.mjs");
+  const hasTsConfig = existsSync("tsconfig.json");
+  const hasPyproject = existsSync("pyproject.toml") || existsSync("requirements.txt") || existsSync("setup.py");
+  const hasPrisma = existsSync("prisma/schema.prisma");
+  const hasApi = existsSync("server") || existsSync("api") || existsSync("backend");
+  const hasGoMod = existsSync("go.mod");
+  if (hasNext && (hasPrisma || hasApi)) return "fullstack";
+  if (hasNext) return "nextjs";
+  if (hasTsConfig) return "typescript";
+  if (hasPyproject) return "python";
+  if (hasGoMod) return "go";
+  return "unknown";
+}
+
+// src/commands/init.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function getTemplatePath(stack) {
+  const name = stack === "unknown" ? "_base" : stack;
+  const candidates = [
+    join(__dirname, "templates", `${name}.yaml`),
+    // dist/templates/ (published package)
+    join(__dirname, "../../../templates", `${name}.yaml`),
+    // monorepo dev fallback
+    join(process.cwd(), "templates", `${name}.yaml`)
+    // cwd fallback
+  ];
+  for (const p of candidates) {
+    if (existsSync2(p)) return p;
+  }
+  return "";
+}
+function getMasterPromptPath() {
+  const candidates = [
+    join(__dirname, "templates/MASTER_PROMPT.md"),
+    // dist/templates/ (published package)
+    join(__dirname, "../../../templates/MASTER_PROMPT.md"),
+    // monorepo dev fallback
+    join(process.cwd(), "templates/MASTER_PROMPT.md")
+    // cwd fallback
+  ];
+  for (const p of candidates) {
+    if (existsSync2(p)) return p;
+  }
+  return "";
+}
+var MINIMAL_CHECKS_YAML = `version: 1
+context:
+  guides: {}
+conditions: []
+checks:
+  - id: lint
+    label: "Lint codebase"
+    cmd: "echo 'Add your lint command here'"
+
+  - id: jsdoc
+    label: "JSDoc on changed public functions"
+    prompt: "Ensure all changed public functions and exports have JSDoc comments."
+`;
+async function initCommand(options) {
+  const spinner = ora("Initialising Holdpoint\u2026").start();
+  const stack = options.stack ?? detectStack();
+  const agent = options.agent ?? detectAgent();
+  spinner.text = `Detected stack: ${chalk.cyan(stack)}, agent: ${chalk.cyan(agent)}`;
+  let yamlContent = MINIMAL_CHECKS_YAML;
+  if (!existsSync2("checks.yaml")) {
+    const templatePath = getTemplatePath(stack);
+    if (templatePath) {
+      yamlContent = readFileSync(templatePath, "utf8");
+    }
+    writeFileSync("checks.yaml", yamlContent, "utf8");
+  } else {
+    yamlContent = readFileSync("checks.yaml", "utf8");
+  }
+  const config = parseHoldpointYaml(yamlContent);
+  const generatedDir = ".github/holdpoint/generated";
+  mkdirSync(generatedDir, { recursive: true });
+  writeFileSync(`${generatedDir}/checks.immutable.json`, buildConfigJson(config), "utf8");
+  if (agent === "copilot" || agent === "unknown") {
+    const hooksDir = ".github/hooks";
+    mkdirSync(hooksDir, { recursive: true });
+    writeFileSync(join(hooksDir, "holdpoint.json"), buildHookJson(config), "utf8");
+    writeFileSync(join(hooksDir, "holdpoint-check.mjs"), buildCheckScript(config), "utf8");
+  }
+  if (agent === "claude") {
+    mkdirSync(".claude", { recursive: true });
+    const settingsPath = ".claude/settings.json";
+    let existing = {};
+    if (existsSync2(settingsPath)) {
+      try {
+        existing = JSON.parse(readFileSync(settingsPath, "utf8"));
+      } catch {
+      }
+    }
+    const holdpointHooks = JSON.parse(buildClaudeEngineJson(config));
+    writeFileSync(
+      settingsPath,
+      JSON.stringify({ ...existing, hooks: holdpointHooks.hooks }, null, 2),
+      "utf8"
+    );
+  }
+  if (agent === "cursor") {
+    const cursorRules = buildCursorEngine(config);
+    const cursorPath = ".cursorrules";
+    if (existsSync2(cursorPath)) {
+      const existing = readFileSync(cursorPath, "utf8");
+      if (!existing.includes("Holdpoint Rules")) {
+        writeFileSync(cursorPath, existing + "\n" + cursorRules, "utf8");
+      }
+    } else {
+      writeFileSync(cursorPath, cursorRules, "utf8");
+    }
+  }
+  if (!existsSync2("MASTER_PROMPT.md")) {
+    const guidePath = getMasterPromptPath();
+    if (guidePath) {
+      copyFileSync(guidePath, "MASTER_PROMPT.md");
+    } else {
+      writeFileSync(
+        "MASTER_PROMPT.md",
+        "# Holdpoint\n\nRun `npx holdpoint check` before marking any task complete.\nSee `checks.yaml` for the full list of checks.\n",
+        "utf8"
+      );
+    }
+  }
+  spinner.succeed(chalk.bold.green("Holdpoint initialised!"));
+  console.log(`
+${chalk.cyan("Next steps:")}
+  1. Edit ${chalk.yellow("checks.yaml")} to customise your eval checkpoints
+  2. Commit ${chalk.yellow("checks.yaml")} and the generated engine files
+  3. Run ${chalk.yellow("npx holdpoint check")} at any time to validate
+
+  Visual builder: ${chalk.yellow("npx holdpoint builder")}  (opens localhost:4321)
+  Stack: ${chalk.cyan(stack)}  Agent: ${chalk.cyan(agent)}
+`);
+}
+
+// src/commands/check.ts
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
+import chalk2 from "chalk";
+import ora2 from "ora";
+import { parseHoldpointYaml as parseHoldpointYaml2, matchesWhen } from "@holdpoint/yaml-core";
+import { runDeterministicChecks } from "@holdpoint/yaml-core/runner";
+import { execSync as execSync3 } from "child_process";
+
+// src/evolve/scanner.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2, readdirSync } from "fs";
+import { join as join2 } from "path";
+import { execSync } from "child_process";
+function tryReadJson(path) {
+  try {
+    return JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function tryReadText(path) {
+  try {
+    return readFileSync2(path, "utf8");
+  } catch {
+    return "";
+  }
+}
+function scanProject(cwd = process.cwd()) {
+  const exists = (p) => existsSync3(join2(cwd, p));
+  const packageManager = exists("pnpm-lock.yaml") ? "pnpm" : exists("yarn.lock") ? "yarn" : exists("bun.lockb") ? "bun" : "npm";
+  const pkg = tryReadJson(join2(cwd, "package.json"));
+  const scripts = pkg?.scripts ?? {};
+  const deps = /* @__PURE__ */ new Set([
+    ...Object.keys(pkg?.dependencies ?? {}),
+    ...Object.keys(pkg?.devDependencies ?? {})
+  ]);
+  const pyprojectText = tryReadText(join2(cwd, "pyproject.toml"));
+  const requirementsText = tryReadText(join2(cwd, "requirements.txt"));
+  const pipfileText = tryReadText(join2(cwd, "Pipfile"));
+  const allPyText = pyprojectText + requirementsText + pipfileText;
+  const hasPytest = exists("pytest.ini") || exists("setup.cfg") || allPyText.includes("pytest") || allPyText.includes("[tool.pytest");
+  const hasRuff = allPyText.includes("ruff") || deps.has("ruff");
+  const hasAlembic = allPyText.includes("alembic") || deps.has("alembic");
+  let rootFiles = [];
+  try {
+    rootFiles = readdirSync(cwd);
+  } catch {
+  }
+  const hasDocker = rootFiles.some((f) => f === "Dockerfile" || f.startsWith("Dockerfile.")) || exists("docker-compose.yml") || exists("docker-compose.yaml") || exists("docker-compose.dev.yml");
+  const hasTerraform = rootFiles.some((f) => f.endsWith(".tf")) || exists("terraform") || exists("infra");
+  return {
+    // Languages
+    hasTypeScript: exists("tsconfig.json") || deps.has("typescript"),
+    hasPython: Boolean(pyprojectText) || Boolean(requirementsText) || Boolean(pipfileText) || exists("setup.py"),
+    hasGo: exists("go.mod"),
+    hasRust: exists("Cargo.toml"),
+    hasJava: exists("pom.xml") || exists("build.gradle") || exists("build.gradle.kts"),
+    hasRuby: exists("Gemfile"),
+    // Frameworks
+    hasNext: exists("next.config.ts") || exists("next.config.js") || exists("next.config.mjs") || deps.has("next"),
+    hasReact: deps.has("react"),
+    // Linting
+    hasEslint: exists("eslint.config.js") || exists("eslint.config.ts") || exists("eslint.config.mjs") || exists(".eslintrc.js") || exists(".eslintrc.json") || exists(".eslintrc.yml") || exists(".eslintrc.yaml") || deps.has("eslint"),
+    hasBiome: exists("biome.json") || exists("biome.jsonc") || deps.has("@biomejs/biome"),
+    hasRuff,
+    hasPrettier: exists("prettier.config.js") || exists("prettier.config.ts") || exists("prettier.config.mjs") || exists(".prettierrc") || exists(".prettierrc.json") || deps.has("prettier"),
+    // Testing
+    hasVitest: deps.has("vitest") || Boolean(scripts["test"]?.includes("vitest")),
+    hasJest: deps.has("jest") || Boolean(scripts["test"]?.includes("jest")),
+    hasPytest,
+    // DB
+    hasPrisma: exists("prisma/schema.prisma") || deps.has("@prisma/client"),
+    hasDrizzle: deps.has("drizzle-orm"),
+    hasMigrations: exists("migrations") || exists("db/migrations") || exists("database/migrations"),
+    hasAlembic,
+    // Infra
+    hasDocker,
+    hasTerraform,
+    hasKubernetes: exists("k8s") || exists("kubernetes") || exists("helm"),
+    // API
+    hasOpenApi: exists("openapi.yaml") || exists("openapi.yml") || exists("openapi.json") || exists("api/openapi.yaml"),
+    // CI
+    hasGithubActions: exists(".github/workflows"),
+    packageManager,
+    scripts,
+    deps
+  };
+}
+
+// src/evolve/templates.ts
+function pmScript(profile, script, fallback) {
+  if (!profile.scripts[script]) return fallback;
+  if (profile.packageManager === "npm") return `npm run ${script}`;
+  return `${profile.packageManager} ${script}`;
+}
+function getTemplates(profile) {
+  return [
+    // ── Universal checks (always proposed for any project) ──────────────────
+    {
+      id: "git-commit",
+      label: "Commit all changes before finishing",
+      cmd: 'git rev-parse --is-inside-work-tree 2>/dev/null || exit 0; [ -z "$(git status --porcelain)" ] && exit 0; git status --short; exit 1',
+      trigger: () => true
+    },
+    {
+      id: "changelog-update",
+      label: "Add a CHANGELOG.md entry for this session",
+      prompt: "Before committing, add an entry to CHANGELOG.md describing what was done. Use Keep a Changelog format \u2014 add under ## [Unreleased] (create the file and that section if absent). Group entries as Added, Changed, Fixed, or Removed. Be concise but specific. The entry text will serve as the commit message.",
+      trigger: () => true
+    },
+    {
+      id: "readme-sync",
+      label: "Update README.md if user-facing changes were made",
+      prompt: "If you added, changed, or removed user-facing functionality \u2014 CLI commands, configuration options, public APIs, or significant new features \u2014 update README.md to reflect those changes.",
+      trigger: () => true
+    },
+    {
+      id: "no-todos",
+      label: "No TODO/FIXME left in changed code",
+      prompt: "Scan the files you changed for any TODO, FIXME, HACK, or XXX comments. Either resolve them before finishing or convert them to GitHub issues. Don't leave incomplete work silently behind.",
+      trigger: () => true
+    },
+    // ── TypeScript / JavaScript ──────────────────────────────────────────────
+    {
+      id: "typecheck",
+      label: "TypeScript type check",
+      cmd: pmScript(profile, "typecheck", "npx tsc --noEmit"),
+      trigger: (p) => p.hasTypeScript
+    },
+    {
+      id: "lint",
+      label: "Lint codebase",
+      cmd: profile.hasEslint ? pmScript(profile, "lint", "npx eslint .") : profile.hasBiome ? pmScript(profile, "lint", "npx @biomejs/biome check .") : pmScript(profile, "lint", "echo 'No linter detected'"),
+      trigger: (p) => p.hasEslint || p.hasBiome
+    },
+    {
+      id: "format-check",
+      label: "Prettier \u2014 format check",
+      cmd: pmScript(profile, "format:check", "npx prettier --check ."),
+      trigger: (p) => p.hasPrettier
+    },
+    {
+      id: "test",
+      label: "Unit tests",
+      cmd: profile.hasVitest ? pmScript(profile, "test", "npx vitest run") : pmScript(profile, "test", "npx jest --passWithNoTests"),
+      trigger: (p) => p.hasVitest || p.hasJest
+    },
+    {
+      id: "jsdoc",
+      label: "JSDoc on changed public functions",
+      prompt: "Ensure all changed public functions, classes, and module exports have accurate JSDoc comments (description + @param + @returns where applicable).",
+      trigger: (p) => p.hasTypeScript || p.hasReact
+    },
+    {
+      id: "build",
+      label: "Production build passes",
+      cmd: pmScript(profile, "build", "echo 'No build script detected'"),
+      trigger: (p) => Boolean(p.scripts["build"])
+    },
+    // ── Python ───────────────────────────────────────────────────────────────
+    {
+      id: "python-lint",
+      label: "Ruff \u2014 Python linting",
+      cmd: "ruff check .",
+      when: "python",
+      trigger: (p) => p.hasPython && p.hasRuff
+    },
+    {
+      id: "python-test",
+      label: "Pytest \u2014 Python unit tests",
+      cmd: "pytest",
+      when: "python",
+      trigger: (p) => p.hasPython && p.hasPytest
+    },
+    // ── Go ───────────────────────────────────────────────────────────────────
+    {
+      id: "go-test",
+      label: "Go tests",
+      cmd: "go test ./...",
+      when: "go",
+      trigger: (p) => p.hasGo
+    },
+    {
+      id: "go-vet",
+      label: "Go vet",
+      cmd: "go vet ./...",
+      when: "go",
+      trigger: (p) => p.hasGo
+    },
+    // ── Database ─────────────────────────────────────────────────────────────
+    {
+      id: "db-migrations",
+      label: "Database migration for schema changes",
+      when: "database",
+      prompt: "If schema or migration files changed, ensure the appropriate migration was generated with your ORM tool (e.g. `prisma migrate dev`, `alembic revision`, `rails db:migrate`) and committed alongside the schema change.",
+      trigger: (p) => p.hasPrisma || p.hasAlembic || p.hasMigrations || p.hasDrizzle
+    },
+    {
+      id: "prisma-format",
+      label: "Prisma schema format check",
+      when: "prisma",
+      cmd: "npx prisma format --check 2>/dev/null || npx prisma format",
+      conditionId: "has-prisma",
+      condition: {
+        id: "has-prisma",
+        operator: "file_exists",
+        path: "prisma/schema.prisma"
+      },
+      trigger: (p) => p.hasPrisma
+    },
+    // ── OpenAPI ──────────────────────────────────────────────────────────────
+    {
+      id: "openapi-sync",
+      label: "OpenAPI spec updated for API changes",
+      when: "backend",
+      conditionId: "has-openapi",
+      condition: {
+        id: "has-openapi",
+        operator: "file_exists",
+        path: "openapi.yaml"
+      },
+      prompt: "If any API routes were added or changed, update openapi.yaml (or openapi.json) to reflect the new endpoints, request/response shapes, and error codes.",
+      trigger: (p) => p.hasOpenApi
+    },
+    // ── Infra ─────────────────────────────────────────────────────────────────
+    {
+      id: "docker-build",
+      label: "Docker build passes",
+      when: "infra",
+      cmd: "docker build . --quiet -t app:ci",
+      conditionId: "has-dockerfile",
+      condition: {
+        id: "has-dockerfile",
+        operator: "file_exists",
+        path: "Dockerfile"
+      },
+      trigger: (p) => p.hasDocker
+    },
+    {
+      id: "terraform-validate",
+      label: "Terraform validate",
+      when: "infra",
+      cmd: "terraform validate",
+      trigger: (p) => p.hasTerraform
+    },
+    // ── Frontend ─────────────────────────────────────────────────────────────
+    {
+      id: "i18n",
+      label: "i18n \u2014 no hardcoded user-facing strings",
+      when: "frontend",
+      prompt: "Confirm all user-visible strings are wrapped in the project's i18n function (e.g. `t()`, `useTranslation`, `<Trans>`) and that locale files are updated for any new copy.",
+      trigger: (p) => p.hasNext && p.hasReact
+    }
+  ];
+}
+
+// src/evolve/dead-checker.ts
+import { execSync as execSync2 } from "child_process";
+import { readdirSync as readdirSync2, existsSync as existsSync4 } from "fs";
+import { join as join3 } from "path";
+var NAMED_SCOPES = /* @__PURE__ */ new Set([
+  "frontend",
+  "backend",
+  "socket",
+  "visual",
+  "python",
+  "go",
+  "rust",
+  "java",
+  "ruby",
+  "database",
+  "prisma",
+  "testing",
+  "infra",
+  "ci",
+  "docs",
+  "structural"
+]);
+var WALK_IGNORED = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".turbo",
+  "__pycache__",
+  ".venv",
+  "venv",
+  ".mypy_cache",
+  "target",
+  ".cache",
+  "coverage"
+]);
+function walkDir(dir, root, depth, maxDepth) {
+  if (depth > maxDepth) return [];
+  let entries = [];
+  try {
+    entries = readdirSync2(dir);
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const entry of entries) {
+    if (WALK_IGNORED.has(entry) || entry.startsWith(".")) continue;
+    const full = join3(dir, entry);
+    const rel = full.slice(root.length + 1);
+    results.push(rel);
+    const children = walkDir(full, root, depth + 1, maxDepth);
+    results.push(...children);
+  }
+  return results;
+}
+function getRepoFiles(cwd) {
+  try {
+    const out = execSync2("git ls-files", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    const files = out.trim().split("\n").filter(Boolean);
+    if (files.length > 0) return files;
+  } catch {
+  }
+  return walkDir(cwd, cwd, 0, 6);
+}
+function extractPathFromRegex(pattern) {
+  const cleaned = pattern.replace(/^\^/, "").replace(/\$$/, "").replace(/\\\./g, ".").replace(/\(\?:/g, "").replace(/\)/g, "").replace(/[|*+?[\]{}()]/g, "");
+  const candidate = cleaned.replace(/\/$/, "").trim();
+  if (candidate.length > 0 && /^[\w\-./]+$/.test(candidate)) return candidate;
+  return void 0;
+}
+function detectStaleChecks(config, repoFiles) {
+  const stale = [];
+  const userPatterns = config.patterns ?? {};
+  for (const check of config.checks) {
+    if (!check.when) continue;
+    if (NAMED_SCOPES.has(check.when)) continue;
+    if (check.conditionId) continue;
+    const patternAlias = check.when in userPatterns ? check.when : void 0;
+    const regexStr = patternAlias ? userPatterns[patternAlias] : check.when;
+    let re;
+    try {
+      re = new RegExp(regexStr);
+    } catch {
+      stale.push({ check, reason: `Invalid regex: '${regexStr}'` });
+      continue;
+    }
+    const matches = repoFiles.filter((f) => re.test(f));
+    if (matches.length === 0) {
+      const label = patternAlias ? `Pattern '${patternAlias}' (= '${regexStr}')` : `Regex '${regexStr}'`;
+      const suggestedConditionPath = extractPathFromRegex(regexStr);
+      const pathGone = !suggestedConditionPath || !existsSync4(join3(process.cwd(), suggestedConditionPath));
+      if (pathGone) {
+        stale.push({
+          check,
+          reason: `${label} matches 0 files in the repo`,
+          ...suggestedConditionPath ? { suggestedConditionPath } : {}
+        });
+      }
+    }
+  }
+  return stale;
+}
+
+// src/commands/check.ts
+function getStagedFiles() {
+  try {
+    const out = execSync3("git diff --cached --name-only", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    return out.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function getAllChangedFiles() {
+  try {
+    const out = execSync3("git diff --name-only HEAD", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    return out.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+async function checkCommand(options) {
+  if (!existsSync5("checks.yaml")) {
+    console.error(chalk2.red("No checks.yaml found. Run `holdpoint init` first."));
+    process.exit(1);
+  }
+  const yamlContent = readFileSync3("checks.yaml", "utf8");
+  let config;
+  try {
+    config = parseHoldpointYaml2(yamlContent);
+  } catch (err) {
+    console.error(chalk2.red("Invalid checks.yaml:"), err.message);
+    process.exit(1);
+  }
+  const changedFiles = options.staged ? getStagedFiles() : getAllChangedFiles();
+  const guides = Object.entries(config.context?.guides ?? {});
+  if (guides.length > 0) {
+    console.log(chalk2.cyan("\nProject guides:"));
+    for (const [key, text] of guides) {
+      console.log(chalk2.bold(`  ${key}:`), chalk2.dim(String(text).trim()));
+    }
+    console.log("");
+  }
+  if (changedFiles.length === 0) {
+    console.log(chalk2.yellow("No changed files detected. Running all checks with no file filter."));
+  }
+  const taskCount = config.checks.filter((c) => c.cmd !== void 0).length;
+  const spinner = ora2(`Running ${taskCount} task(s)\u2026`).start();
+  const effectiveFiles = changedFiles.length > 0 ? changedFiles : ["__all__"];
+  const results = runDeterministicChecks(config, effectiveFiles);
+  const runDrift = matchesWhen("structural", effectiveFiles);
+  if (runDrift) {
+    const profile = scanProject();
+    const existingIds = new Set(config.checks.map((c) => c.id));
+    const templates = getTemplates(profile);
+    const proposals = templates.filter((t) => t.trigger(profile) && !existingIds.has(t.id));
+    const repoFiles = getRepoFiles(process.cwd());
+    const staleChecks = detectStaleChecks(config, repoFiles);
+    if (proposals.length > 0 || staleChecks.length > 0) {
+      const lines = [];
+      if (proposals.length > 0) {
+        lines.push(`${proposals.length} new check(s) available for your project stack:`);
+        for (const p of proposals) lines.push(`  + ${p.label}`);
+      }
+      if (staleChecks.length > 0) {
+        lines.push(`${staleChecks.length} stale check(s) no longer match your project:`);
+        for (const s of staleChecks) lines.push(`  - ${s.check.label}: ${s.reason}`);
+      }
+      lines.push("\nRun: npx holdpoint evolve --apply");
+      results.push({
+        check: { id: "__holdpoint_evolve__", label: "Evolve checks with project structure" },
+        status: "fail",
+        output: lines.join("\n")
+      });
+    }
+  }
+  const passed = results.filter((r) => r.status === "pass");
+  const failed = results.filter((r) => r.status === "fail");
+  const skipped = results.filter((r) => r.status === "skip");
+  spinner.stop();
+  for (const result of results) {
+    printResult(result);
+  }
+  console.log("");
+  console.log(
+    [
+      chalk2.green(`\u2713 ${passed.length} passed`),
+      failed.length > 0 ? chalk2.red(`\u2717 ${failed.length} failed`) : "",
+      skipped.length > 0 ? chalk2.gray(`\u25CC ${skipped.length} skipped`) : ""
+    ].filter(Boolean).join("  ")
+  );
+  const promptChecks = config.checks.filter(
+    (c) => c.prompt !== void 0 && matchesWhen(c.when, changedFiles.length > 0 ? changedFiles : ["__all__"], config.patterns)
+  );
+  if (promptChecks.length > 0) {
+    console.log(`
+${chalk2.cyan("Agent prompts to act on:")}`);
+    for (const c of promptChecks) {
+      console.log(`  ${chalk2.yellow("\u25A1")} [${c.label}] ${c.prompt ?? ""}`);
+    }
+  }
+  if (failed.length > 0) {
+    process.exit(1);
+  }
+}
+function printResult(result) {
+  const icon = result.status === "pass" ? chalk2.green("\u2713") : result.status === "fail" ? chalk2.red("\u2717") : result.status === "skip" ? chalk2.gray("\u25CC") : chalk2.yellow("\u2026");
+  const label = result.check.label;
+  console.log(`${icon} ${label}`);
+  if (result.status === "fail" && result.output) {
+    const trimmed = result.output.trim().split("\n").slice(0, 10).join("\n");
+    console.log(chalk2.dim(trimmed.replace(/^/gm, "    ")));
+  }
+  if (result.status === "skip" && result.skipReason) {
+    console.log(chalk2.dim(`    ${result.skipReason}`));
+  }
+}
+
+// src/commands/validate.ts
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
+import chalk3 from "chalk";
+import { parseHoldpointYaml as parseHoldpointYaml3, validateConfig } from "@holdpoint/yaml-core";
+async function validateCommand() {
+  if (!existsSync6("checks.yaml")) {
+    console.error(chalk3.red("No checks.yaml found. Run `holdpoint init` first."));
+    process.exit(1);
+  }
+  const text = readFileSync4("checks.yaml", "utf8");
+  let config;
+  try {
+    config = parseHoldpointYaml3(text);
+  } catch (err) {
+    console.error(chalk3.red("Parse error:"), err.message);
+    process.exit(1);
+  }
+  const result = validateConfig(config);
+  if (result.valid) {
+    console.log(chalk3.green("\u2713 checks.yaml is valid"));
+    console.log(
+      chalk3.dim(
+        `  ${config.checks.filter((c) => c.cmd !== void 0).length} tasks, ${config.checks.filter((c) => c.prompt !== void 0).length} prompts, ${config.conditions.length} conditions`
+      )
+    );
+  } else {
+    console.error(chalk3.red("\u2717 checks.yaml has errors:"));
+    for (const err of result.errors) {
+      console.error(`  ${chalk3.yellow(err.path)}: ${err.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/update.ts
+import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import chalk4 from "chalk";
+import ora3 from "ora";
+import { parseHoldpointYaml as parseHoldpointYaml4 } from "@holdpoint/yaml-core";
+import { buildHookJson as buildHookJson2, buildCheckScript as buildCheckScript2, buildConfigJson as buildConfigJson2 } from "@holdpoint/engine-copilot";
+import { buildEngineJson as buildClaudeEngineJson2 } from "@holdpoint/engine-claude";
+import { buildEngine as buildCursorEngine2 } from "@holdpoint/engine-cursor";
+async function updateCommand() {
+  if (!existsSync7("checks.yaml")) {
+    console.error(chalk4.red("No checks.yaml found. Run `holdpoint init` first."));
+    process.exit(1);
+  }
+  const spinner = ora3("Updating Holdpoint engine files\u2026").start();
+  const agent = detectAgent();
+  const config = parseHoldpointYaml4(readFileSync5("checks.yaml", "utf8"));
+  const generatedDir = ".github/holdpoint/generated";
+  mkdirSync2(generatedDir, { recursive: true });
+  writeFileSync2(`${generatedDir}/checks.immutable.json`, buildConfigJson2(config), "utf8");
+  if (agent === "copilot" || agent === "unknown") {
+    const hooksDir = ".github/hooks";
+    mkdirSync2(hooksDir, { recursive: true });
+    writeFileSync2(`${hooksDir}/holdpoint.json`, buildHookJson2(config), "utf8");
+    writeFileSync2(`${hooksDir}/holdpoint-check.mjs`, buildCheckScript2(config), "utf8");
+    spinner.text = `Updated ${chalk4.green(".github/hooks/holdpoint.json")} and ${chalk4.green(".github/hooks/holdpoint-check.mjs")}`;
+  }
+  if (agent === "claude") {
+    mkdirSync2(".claude", { recursive: true });
+    const settingsPath = ".claude/settings.json";
+    let existing = {};
+    if (existsSync7(settingsPath)) {
+      try {
+        existing = JSON.parse(readFileSync5(settingsPath, "utf8"));
+      } catch {
+      }
+    }
+    const hooks = JSON.parse(buildClaudeEngineJson2(config));
+    writeFileSync2(settingsPath, JSON.stringify({ ...existing, hooks: hooks.hooks }, null, 2));
+  }
+  if (agent === "cursor") {
+    const cursorRules = buildCursorEngine2(config);
+    const cursorPath = ".cursorrules";
+    if (existsSync7(cursorPath)) {
+      const content = readFileSync5(cursorPath, "utf8");
+      const start = content.indexOf("# \u2500\u2500\u2500 Holdpoint Rules");
+      const end = content.indexOf("# \u2500\u2500\u2500 End Holdpoint Rules \u2500\u2500\u2500");
+      if (start !== -1 && end !== -1) {
+        const afterEnd = content.indexOf("\n", end);
+        const updated = content.slice(0, start) + cursorRules + content.slice(afterEnd === -1 ? end : afterEnd + 1);
+        writeFileSync2(cursorPath, updated);
+      } else {
+        writeFileSync2(cursorPath, content + "\n" + cursorRules);
+      }
+    }
+  }
+  spinner.succeed(chalk4.green("Engine files updated from current checks.yaml"));
+}
+
+// src/commands/build.ts
+import { createServer } from "http";
+import { createReadStream, existsSync as existsSync8 } from "fs";
+import { join as join4, extname, dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { execSync as execSync4 } from "child_process";
+import chalk5 from "chalk";
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript",
+  ".mjs": "text/javascript",
+  ".css": "text/css",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".json": "application/json"
+};
+function serveFile(res, filePath) {
+  const mime = MIME[extname(filePath)] ?? "application/octet-stream";
+  res.writeHead(200, { "Content-Type": mime });
+  createReadStream(filePath).pipe(res);
+}
+function handleRequest(req, res, uiDir) {
+  const url = (req.url ?? "/").split("?")[0] ?? "/";
+  if (url === "/__holdpoint/initial-yaml") {
+    const checksPath = join4(process.cwd(), "checks.yaml");
+    if (existsSync8(checksPath)) {
+      res.writeHead(200, { "Content-Type": "text/yaml; charset=utf-8" });
+      createReadStream(checksPath).pipe(res);
+    } else {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("checks.yaml not found in current directory");
+    }
+    return;
+  }
+  const candidate = join4(uiDir, url === "/" ? "index.html" : url);
+  const filePath = existsSync8(candidate) ? candidate : join4(uiDir, "index.html");
+  serveFile(res, filePath);
+}
+async function buildCommand() {
+  const port = 4321;
+  const uiDir = join4(__dirname2, "builder-ui");
+  if (!existsSync8(uiDir)) {
+    console.error(chalk5.red("\u2717 Builder UI not found.\n"));
+    console.log(chalk5.dim("  This is unexpected for a published build of @holdpoint/cli."));
+    console.log(chalk5.dim("  If you installed from source, rebuild with: pnpm turbo build\n"));
+    process.exit(1);
+  }
+  const server = createServer((req, res) => handleRequest(req, res, uiDir));
+  await new Promise((resolve, reject) => {
+    server.listen(port, () => {
+      console.log(
+        `
+${chalk5.green("\u2713")} Holdpoint builder running at ${chalk5.cyan(`http://localhost:${port}`)}`
+      );
+      console.log(chalk5.dim("  Edit checks.yaml, then reload the page to see updates"));
+      console.log(chalk5.dim("  Press Ctrl+C to stop\n"));
+      const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+      try {
+        execSync4(`${openCmd} http://localhost:${port}`, { stdio: "ignore" });
+      } catch {
+      }
+    });
+    server.on("error", reject);
+    process.on("SIGINT", () => {
+      console.log(chalk5.dim("\n  Stopping builder\u2026"));
+      server.close(() => resolve());
+    });
+  });
+}
+
+// src/commands/evolve.ts
+import { existsSync as existsSync9, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { execSync as execSync5 } from "child_process";
+import chalk6 from "chalk";
+import ora4 from "ora";
+import { parseHoldpointYaml as parseHoldpointYaml5, generateYaml } from "@holdpoint/yaml-core";
+function extractHeader(yaml) {
+  const lines = yaml.split("\n");
+  const commentLines = [];
+  for (const line of lines) {
+    if (line.startsWith("#") || commentLines.length > 0 && line.trim() === "") {
+      commentLines.push(line);
+    } else {
+      break;
+    }
+  }
+  while (commentLines.length > 0 && commentLines[commentLines.length - 1]?.trim() === "") {
+    commentLines.pop();
+  }
+  return commentLines.join("\n");
+}
+function withHeader(header, newYaml) {
+  if (!header) return newYaml;
+  return header + "\n\n" + newYaml;
+}
+async function evolveCommand(options) {
+  if (!existsSync9("checks.yaml")) {
+    console.error(chalk6.red("No checks.yaml found. Run `holdpoint init` first."));
+    process.exit(1);
+  }
+  const spinner = ora4("Scanning project profile\u2026").start();
+  const cwd = process.cwd();
+  const profile = scanProject(cwd);
+  const repoFiles = getRepoFiles(cwd);
+  const yamlContent = readFileSync6("checks.yaml", "utf8");
+  let config;
+  try {
+    config = parseHoldpointYaml5(yamlContent);
+  } catch (err) {
+    spinner.fail(chalk6.red("Invalid checks.yaml:") + " " + err.message);
+    process.exit(1);
+  }
+  spinner.stop();
+  const existingIds = new Set(config.checks.map((c) => c.id));
+  const existingConditionIds = new Set(config.conditions.map((c) => c.id));
+  const allTemplates = getTemplates(profile);
+  const proposals = allTemplates.filter((t) => t.trigger(profile) && !existingIds.has(t.id));
+  const staleChecks = detectStaleChecks(config, repoFiles);
+  console.log(chalk6.bold("\n\u{1F4CB} Project profile:"));
+  const traits = [
+    ["TypeScript", profile.hasTypeScript, "tsconfig.json"],
+    ["ESLint", profile.hasEslint, "eslint.config.*"],
+    ["Biome", profile.hasBiome, "biome.json"],
+    ["Ruff", profile.hasRuff, "pyproject.toml / ruff"],
+    ["Prettier", profile.hasPrettier, ".prettierrc"],
+    ["Vitest", profile.hasVitest, "devDependencies"],
+    ["Jest", profile.hasJest, "devDependencies"],
+    ["Python", profile.hasPython, "pyproject.toml"],
+    ["Pytest", profile.hasPytest, "pytest.ini"],
+    ["Go", profile.hasGo, "go.mod"],
+    ["Rust", profile.hasRust, "Cargo.toml"],
+    ["Next.js", profile.hasNext, "next.config.*"],
+    ["React", profile.hasReact, "dependencies"],
+    ["Prisma", profile.hasPrisma, "prisma/schema.prisma"],
+    ["Drizzle", profile.hasDrizzle, "drizzle-orm"],
+    ["Migrations", profile.hasMigrations, "migrations/"],
+    ["Docker", profile.hasDocker, "Dockerfile"],
+    ["Terraform", profile.hasTerraform, "*.tf"],
+    ["Kubernetes", profile.hasKubernetes, "k8s/"],
+    ["OpenAPI", profile.hasOpenApi, "openapi.yaml"],
+    ["GitHub Actions", profile.hasGithubActions, ".github/workflows/"]
+  ];
+  const detected = traits.filter(([, yes]) => yes);
+  if (detected.length === 0) {
+    console.log(chalk6.dim("  (empty project \u2014 only universal checks apply)"));
+  } else {
+    for (const [name, , hint] of detected) {
+      console.log(`  ${chalk6.green("\u2713")} ${name.padEnd(18)} ${chalk6.dim(hint)}`);
+    }
+  }
+  if (staleChecks.length > 0) {
+    console.log(chalk6.bold(`
+\u26A0\uFE0F  Stale checks (${staleChecks.length}):`));
+    for (const { check, reason, suggestedConditionPath } of staleChecks) {
+      const fix = suggestedConditionPath ? chalk6.dim(` \u2192 will wrap with conditionId: file_exists: ${suggestedConditionPath}`) : chalk6.dim(" \u2192 no path inferred; review manually");
+      console.log(`  ${chalk6.yellow("\u25CC")} ${chalk6.bold(check.id)}  ${chalk6.dim(reason)}${fix}`);
+    }
+  }
+  if (proposals.length === 0 && staleChecks.length === 0) {
+    console.log(chalk6.green("\n\u2713 checks.yaml is fully in sync with the project profile."));
+    return;
+  }
+  if (proposals.length > 0) {
+    console.log(chalk6.bold(`
+\u{1F4A1} Proposed additions (${proposals.length}):`));
+    for (const t of proposals) {
+      const scope = t.when ? chalk6.cyan(` when: ${t.when}`) : "";
+      const type = t.cmd ? chalk6.dim("cmd") : chalk6.dim("prompt");
+      const preview = t.cmd ? chalk6.dim(`  ${t.cmd.slice(0, 80)}${t.cmd.length > 80 ? "\u2026" : ""}`) : chalk6.dim(`  ${(t.prompt ?? "").slice(0, 80)}${(t.prompt?.length ?? 0) > 80 ? "\u2026" : ""}`);
+      console.log(`  ${chalk6.green("+")} ${chalk6.bold(t.id.padEnd(24))} [${type}]${scope}`);
+      console.log(`    ${preview}`);
+    }
+  }
+  if (!options.apply) {
+    console.log(
+      chalk6.red(`
+\u2717 checks.yaml is out of sync with the project profile.`) + `
+  Run ${chalk6.bold("npx holdpoint evolve --apply")} to apply these changes.`
+    );
+    process.exit(1);
+  }
+  const applySpinner = ora4("Applying changes to checks.yaml\u2026").start();
+  const newConditions = [...config.conditions];
+  for (const t of proposals) {
+    if (t.condition && !existingConditionIds.has(t.condition.id)) {
+      newConditions.push(t.condition);
+      existingConditionIds.add(t.condition.id);
+    }
+  }
+  const updatedChecks = config.checks.map((check) => {
+    const stale = staleChecks.find((s) => s.check.id === check.id);
+    if (!stale || !stale.suggestedConditionPath) return check;
+    const condId = `has-${check.id}`;
+    if (!existingConditionIds.has(condId)) {
+      newConditions.push({
+        id: condId,
+        operator: "file_exists",
+        path: stale.suggestedConditionPath
+      });
+      existingConditionIds.add(condId);
+    }
+    return { ...check, conditionId: condId };
+  });
+  const newChecks = proposals.map((t) => ({
+    id: t.id,
+    label: t.label,
+    ...t.when ? { when: t.when } : {},
+    ...t.cmd ? { cmd: t.cmd } : {},
+    ...t.prompt ? { prompt: t.prompt } : {},
+    ...t.conditionId ? { conditionId: t.conditionId } : {}
+  }));
+  const updatedConfig = {
+    ...config,
+    conditions: newConditions,
+    checks: [...updatedChecks, ...newChecks]
+  };
+  const header = extractHeader(yamlContent);
+  const newYaml = withHeader(header, generateYaml(updatedConfig));
+  writeFileSync3("checks.yaml", newYaml, "utf8");
+  applySpinner.text = "Running holdpoint update\u2026";
+  try {
+    execSync5("npx holdpoint update", { stdio: "pipe" });
+  } catch {
+    applySpinner.warn(
+      chalk6.yellow("checks.yaml updated, but `holdpoint update` failed \u2014 run it manually.")
+    );
+    printAppliedSummary(proposals.length, staleChecks.length);
+    return;
+  }
+  applySpinner.succeed(chalk6.green("checks.yaml updated and engine files regenerated."));
+  printAppliedSummary(proposals.length, staleChecks.length);
+}
+function printAppliedSummary(added, wrapped) {
+  const parts = [];
+  if (added > 0) parts.push(chalk6.green(`${added} check${added === 1 ? "" : "s"} added`));
+  if (wrapped > 0)
+    parts.push(chalk6.yellow(`${wrapped} stale check${wrapped === 1 ? "" : "s"} wrapped`));
+  if (parts.length > 0) console.log("  " + parts.join("  \xB7  "));
+  console.log(
+    chalk6.dim("\n  Review checks.yaml, then commit: ") + chalk6.yellow("git add checks.yaml && git commit -m 'chore: evolve holdpoint checks'")
+  );
+}
+
+// src/index.ts
+var program = new Command();
+program.name("holdpoint").description("Universal eval-guard for AI coding agents (alpha)").version("0.1.0-alpha.0");
+program.command("init").description("Initialise Holdpoint in the current project").option("--stack <stack>", "Stack type: typescript | python | nextjs | fullstack").option("--agent <agent>", "Agent type: copilot | claude | cursor").action(initCommand);
+program.command("check").description("Run task checks from checks.yaml").option("--staged", "Only check against git-staged files").action(checkCommand);
+program.command("validate").description("Validate checks.yaml schema and print any errors").action(validateCommand);
+program.command("update").description("Regenerate engine files from current checks.yaml (preserves checks.yaml)").action(updateCommand);
+program.command("builder").description("Open the visual builder UI on localhost:4321").action(buildCommand);
+program.command("evolve").description("Scan project and propose (or apply) new checks to keep checks.yaml in sync").option("--apply", "Write proposed changes to checks.yaml and regenerate engine files").action(evolveCommand);
+program.parse();
+//# sourceMappingURL=index.js.map