agentloopkit 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,1144 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command as Command9 } from "commander";
+
+// src/cli/commands/init.ts
+import { Command } from "commander";
+
+// src/core/init.ts
+import path6 from "path";
+import { readdir as readdir3 } from "fs/promises";
+
+// src/core/constants.ts
+var CONFIG_FILE = "agentloop.config.json";
+var AGENTLOOP_DIR = ".agentloop";
+var AGENTS_FILE = "AGENTS.md";
+var AGENTLOOP_FILE = "AGENTLOOP.md";
+var TEMPLATE_GROUPS = [
+  "loops",
+  "gates",
+  "handoffs",
+  "agents",
+  "policies",
+  "tasks",
+  "harness"
+];
+var SUPPORTED_AGENTS = [
+  "codex",
+  "claude-code",
+  "cursor",
+  "opencode",
+  "gemini-cli",
+  "github-copilot-cli",
+  "generic"
+];
+var TASK_TYPES = [
+  "feature",
+  "bugfix",
+  "refactor",
+  "tests",
+  "docs",
+  "release",
+  "security-review",
+  "dependency-upgrade",
+  "migration"
+];
+var DEFAULT_COMMAND_KEYS = ["test", "lint", "typecheck", "build", "format"];
+
+// src/core/config.ts
+import { readFile } from "fs/promises";
+import path from "path";
+import { z } from "zod";
+
+// src/core/errors.ts
+var AgentLoopError = class extends Error {
+  constructor(message, code = "AGENTLOOP_ERROR") {
+    super(message);
+    this.code = code;
+    this.name = "AgentLoopError";
+  }
+  code;
+};
+var ConfigError = class extends AgentLoopError {
+  constructor(message) {
+    super(message, "CONFIG_ERROR");
+    this.name = "ConfigError";
+  }
+};
+
+// src/core/config.ts
+var ProjectTypeSchema = z.enum([
+  "nextjs",
+  "react-vite",
+  "node",
+  "typescript-package",
+  "python",
+  "docs-only",
+  "generic"
+]);
+var PackageManagerSchema = z.enum(["pnpm", "npm", "yarn", "bun"]);
+var CommandConfigSchema = z.object({
+  test: z.string().default(""),
+  lint: z.string().default(""),
+  typecheck: z.string().default(""),
+  build: z.string().default(""),
+  format: z.string().default("")
+});
+var AgentLoopConfigSchema = z.object({
+  $schema: z.string().optional(),
+  version: z.literal(1),
+  project: z.object({
+    name: z.string(),
+    type: ProjectTypeSchema,
+    packageManager: PackageManagerSchema
+  }),
+  paths: z.object({
+    root: z.string(),
+    agentloopDir: z.string(),
+    tasksDir: z.string(),
+    reportsDir: z.string(),
+    handoffsDir: z.string()
+  }),
+  commands: CommandConfigSchema,
+  safety: z.object({
+    requireCleanWorkingTree: z.boolean(),
+    warnOnDirtyWorkingTree: z.boolean(),
+    protectEnvFiles: z.boolean(),
+    protectMigrations: z.boolean(),
+    protectLockfiles: z.boolean()
+  }),
+  summary: z.object({
+    includeDiffStats: z.boolean(),
+    includeChangedFiles: z.boolean(),
+    includeVerification: z.boolean(),
+    includeRisks: z.boolean(),
+    includeRollback: z.boolean()
+  })
+});
+function createDefaultConfig(input = {}) {
+  return {
+    $schema: "https://agentloopkit.dev/schema/agentloop.config.schema.json",
+    version: 1,
+    project: {
+      name: input.name ?? "",
+      type: input.type ?? "generic",
+      packageManager: input.packageManager ?? "npm"
+    },
+    paths: {
+      root: ".",
+      agentloopDir: ".agentloop",
+      tasksDir: ".agentloop/tasks",
+      reportsDir: ".agentloop/reports",
+      handoffsDir: ".agentloop/handoffs"
+    },
+    commands: {
+      test: input.commands?.test ?? "",
+      lint: input.commands?.lint ?? "",
+      typecheck: input.commands?.typecheck ?? "",
+      build: input.commands?.build ?? "",
+      format: input.commands?.format ?? ""
+    },
+    safety: {
+      requireCleanWorkingTree: false,
+      warnOnDirtyWorkingTree: true,
+      protectEnvFiles: true,
+      protectMigrations: true,
+      protectLockfiles: false
+    },
+    summary: {
+      includeDiffStats: true,
+      includeChangedFiles: true,
+      includeVerification: true,
+      includeRisks: true,
+      includeRollback: true
+    }
+  };
+}
+function parseAgentLoopConfig(value) {
+  const parsed = AgentLoopConfigSchema.safeParse(value);
+  if (!parsed.success) {
+    throw new ConfigError(`Invalid AgentLoopKit config: ${parsed.error.message}`);
+  }
+  return parsed.data;
+}
+async function loadAgentLoopConfig(cwd) {
+  const filePath = path.join(cwd, CONFIG_FILE);
+  const raw = await readFile(filePath, "utf8");
+  return parseAgentLoopConfig(JSON.parse(raw));
+}
+
+// src/core/file-system.ts
+import { access, mkdir, readFile as readFile2, readdir, stat, writeFile } from "fs/promises";
+import path2 from "path";
+async function pathExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readTextIfExists(filePath) {
+  if (!await pathExists(filePath)) return "";
+  return readFile2(filePath, "utf8");
+}
+async function writeTextFile(filePath, content) {
+  await mkdir(path2.dirname(filePath), { recursive: true });
+  await writeFile(filePath, content);
+}
+async function listFilesRecursive(root, options = {}) {
+  const ignore = new Set(
+    options.ignore ?? [".git", ".agentloop", "node_modules", "dist", "coverage"]
+  );
+  const files = [];
+  async function walk(current) {
+    if (!await pathExists(current)) return;
+    const entries = await readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      if (ignore.has(entry.name)) continue;
+      const absolute = path2.join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(absolute);
+      } else if (entry.isFile()) {
+        files.push(absolute);
+      }
+    }
+  }
+  const rootStat = await stat(root).catch(() => void 0);
+  if (!rootStat?.isDirectory()) return [];
+  await walk(root);
+  return files;
+}
+
+// src/core/package-manager.ts
+import { readFile as readFile3 } from "fs/promises";
+import path3 from "path";
+async function detectPackageManager(cwd) {
+  if (await pathExists(path3.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (await pathExists(path3.join(cwd, "bun.lockb"))) return "bun";
+  if (await pathExists(path3.join(cwd, "bun.lock"))) return "bun";
+  if (await pathExists(path3.join(cwd, "yarn.lock"))) return "yarn";
+  if (await pathExists(path3.join(cwd, "package-lock.json"))) return "npm";
+  const packageJsonPath = path3.join(cwd, "package.json");
+  if (await pathExists(packageJsonPath)) {
+    const packageJson = JSON.parse(await readFile3(packageJsonPath, "utf8"));
+    const manager = packageJson.packageManager?.split("@")[0];
+    const parsed = PackageManagerSchema.safeParse(manager);
+    if (parsed.success) return parsed.data;
+  }
+  return "npm";
+}
+function packageManagerRunCommand(manager, scriptName) {
+  return `${manager} run ${scriptName}`;
+}
+
+// src/core/project-detection.ts
+import { readFile as readFile4 } from "fs/promises";
+import path4 from "path";
+async function readPackageJson(cwd) {
+  const filePath = path4.join(cwd, "package.json");
+  if (!await pathExists(filePath)) return void 0;
+  return JSON.parse(await readFile4(filePath, "utf8"));
+}
+async function detectProjectName(cwd) {
+  const packageJson = await readPackageJson(cwd);
+  if (packageJson?.name) return packageJson.name;
+  return path4.basename(cwd);
+}
+async function detectProjectType(cwd) {
+  const packageJson = await readPackageJson(cwd);
+  const deps = { ...packageJson?.dependencies, ...packageJson?.devDependencies };
+  if (deps.next) return "nextjs";
+  if (deps.vite && deps.react) return "react-vite";
+  if (deps.typescript && packageJson) return "typescript-package";
+  if (packageJson) return "node";
+  if (await pathExists(path4.join(cwd, "pyproject.toml")) || await pathExists(path4.join(cwd, "requirements.txt"))) {
+    return "python";
+  }
+  const files = await listFilesRecursive(cwd);
+  const relativeFiles = files.map((file) => path4.relative(cwd, file));
+  const hasCode = relativeFiles.some(
+    (file) => /\.(ts|tsx|js|jsx|py|go|rs|java|rb|php|cs)$/.test(file)
+  );
+  const hasDocs = relativeFiles.some((file) => file.endsWith(".md") || file.startsWith("docs/"));
+  if (hasDocs && !hasCode) return "docs-only";
+  return "generic";
+}
+async function detectPackageScripts(cwd, packageManager) {
+  const packageJson = await readPackageJson(cwd);
+  const commands = { test: "", lint: "", typecheck: "", build: "", format: "" };
+  for (const key of DEFAULT_COMMAND_KEYS) {
+    if (packageJson?.scripts?.[key]) {
+      commands[key] = packageManagerRunCommand(packageManager, key);
+    }
+  }
+  return commands;
+}
+
+// src/core/template-renderer.ts
+import { cp, readFile as readFile5, readdir as readdir2 } from "fs/promises";
+import path5 from "path";
+import { fileURLToPath } from "url";
+function renderTemplateString(template, values) {
+  return template.replace(/\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g, (match, key) => {
+    const value = values[key];
+    return value === void 0 ? match : String(value);
+  });
+}
+function getTemplateRoot() {
+  return fileURLToPath(new URL("../templates", import.meta.url));
+}
+async function readTemplate(relativePath, values = {}) {
+  const raw = await readFile5(path5.join(getTemplateRoot(), relativePath), "utf8");
+  return renderTemplateString(raw, values);
+}
+async function listTemplateFiles() {
+  const root = getTemplateRoot();
+  const groups = await readdir2(root, { withFileTypes: true });
+  const result = {};
+  for (const group of groups) {
+    if (!group.isDirectory()) continue;
+    const entries = await readdir2(path5.join(root, group.name), { withFileTypes: true });
+    result[group.name] = entries.filter((entry) => entry.isFile()).map((entry) => entry.name).sort();
+  }
+  return result;
+}
+
+// src/core/init.ts
+async function writeGeneratedFile(filePath, content, result) {
+  if (await pathExists(filePath)) {
+    result.skipped.push(filePath);
+    return;
+  }
+  if (result.dryRun) {
+    result.created.push(filePath);
+    return;
+  }
+  await writeTextFile(filePath, content);
+  result.created.push(filePath);
+}
+async function writeRenderedTemplateGroup(cwd, group, values, result) {
+  const templateDir = path6.join(getTemplateRoot(), group);
+  const entries = await readdir3(templateDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    const relative2 = `${group}/${entry.name}`;
+    await writeGeneratedFile(
+      path6.join(cwd, AGENTLOOP_DIR, group, entry.name),
+      await readTemplate(relative2, values),
+      result
+    );
+  }
+}
+async function upsertAgentsFile(cwd, content, result) {
+  const filePath = path6.join(cwd, AGENTS_FILE);
+  const existing = await readTextIfExists(filePath);
+  const marker = "<!-- agentloopkit:start -->";
+  if (!existing) {
+    if (result.dryRun) {
+      result.created.push(filePath);
+      return;
+    }
+    await writeTextFile(filePath, content);
+    result.created.push(filePath);
+    return;
+  }
+  if (existing.includes(marker)) {
+    result.skipped.push(filePath);
+    return;
+  }
+  const section = content.replace(/^# AGENTS\s*/i, "## AgentLoopKit\n\n").replace("<!-- agentloopkit:start -->", marker);
+  if (result.dryRun) {
+    result.updated.push(filePath);
+    return;
+  }
+  await writeTextFile(filePath, `${existing.trimEnd()}
+
+${section.trim()}
+`);
+  result.updated.push(filePath);
+}
+async function initializeAgentLoop(options) {
+  const result = {
+    created: [],
+    updated: [],
+    skipped: [],
+    dryRun: Boolean(options.dryRun)
+  };
+  const cwd = options.cwd;
+  const packageManager = await detectPackageManager(cwd);
+  const projectType = await detectProjectType(cwd);
+  const projectName = await detectProjectName(cwd);
+  const commands = await detectPackageScripts(cwd, packageManager);
+  const config = createDefaultConfig({
+    name: projectName,
+    type: projectType,
+    packageManager,
+    commands
+  });
+  const values = {
+    projectName,
+    projectType,
+    packageManager,
+    testCommand: commands.test || "not configured",
+    lintCommand: commands.lint || "not configured",
+    typecheckCommand: commands.typecheck || "not configured",
+    buildCommand: commands.build || "not configured",
+    formatCommand: commands.format || "not configured"
+  };
+  for (const group of TEMPLATE_GROUPS) {
+    if (group === "tasks") continue;
+    await writeRenderedTemplateGroup(cwd, group, values, result);
+  }
+  await writeGeneratedFile(
+    path6.join(cwd, AGENTLOOP_DIR, "README.md"),
+    await readTemplate("root/agentloop-directory-readme.md", values),
+    result
+  );
+  await writeGeneratedFile(
+    path6.join(cwd, AGENTLOOP_DIR, "tasks", "README.md"),
+    await readTemplate("tasks/README.md", values),
+    result
+  );
+  await writeGeneratedFile(
+    path6.join(cwd, AGENTLOOP_DIR, "reports", "README.md"),
+    "# Verification Reports\n\nAgentLoopKit writes verification reports here when you run `agentloop verify`.\n",
+    result
+  );
+  const agentsContent = await readTemplate("root/AGENTS.md", values);
+  await upsertAgentsFile(cwd, agentsContent, result);
+  await writeGeneratedFile(
+    path6.join(cwd, AGENTLOOP_FILE),
+    await readTemplate("root/AGENTLOOP.md", values),
+    result
+  );
+  const configPath = path6.join(cwd, CONFIG_FILE);
+  if (await pathExists(configPath)) {
+    result.skipped.push(configPath);
+  } else if (result.dryRun) {
+    result.created.push(configPath);
+  } else {
+    await writeTextFile(configPath, `${JSON.stringify(config, null, 2)}
+`);
+    result.created.push(configPath);
+  }
+  return result;
+}
+
+// src/core/logger.ts
+var consoleLogger = {
+  info: (message) => console.log(message),
+  warn: (message) => console.warn(message),
+  error: (message) => console.error(message)
+};
+
+// src/cli/commands/init.ts
+function initCommand() {
+  return new Command("init").description("Initialize AgentLoopKit in the current repository").option("--dry-run", "show planned changes without writing files").option("--json", "print machine-readable output").action(async (options) => {
+    const result = await initializeAgentLoop({ cwd: process.cwd(), dryRun: options.dryRun });
+    if (options.json) {
+      consoleLogger.info(JSON.stringify(result, null, 2));
+      return;
+    }
+    consoleLogger.info(
+      options.dryRun ? "AgentLoopKit init dry run complete." : "AgentLoopKit initialized."
+    );
+    consoleLogger.info(`Created: ${result.created.length}`);
+    consoleLogger.info(`Updated: ${result.updated.length}`);
+    consoleLogger.info(`Skipped: ${result.skipped.length}`);
+    if (!options.dryRun) {
+      consoleLogger.info("\nNext steps:");
+      consoleLogger.info("- Review AGENTS.md and AGENTLOOP.md");
+      consoleLogger.info("- Run agentloop doctor");
+      consoleLogger.info("- Create a task with agentloop create-task");
+    }
+  });
+}
+
+// src/cli/commands/doctor.ts
+import { Command as Command2 } from "commander";
+
+// src/core/doctor.ts
+import path8 from "path";
+
+// src/core/git.ts
+import { execa } from "execa";
+async function commandExists(command) {
+  const result = await execa(command, ["--version"], { reject: false });
+  return result.exitCode === 0;
+}
+async function isInsideGitRepo(cwd) {
+  const result = await execa("git", ["rev-parse", "--is-inside-work-tree"], { cwd, reject: false });
+  return result.exitCode === 0 && result.stdout.trim() === "true";
+}
+async function getGitBranch(cwd) {
+  const result = await execa("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd, reject: false });
+  return result.exitCode === 0 ? result.stdout.trim() : "";
+}
+async function getGitCommit(cwd) {
+  const result = await execa("git", ["rev-parse", "--short", "HEAD"], { cwd, reject: false });
+  return result.exitCode === 0 ? result.stdout.trim() : "";
+}
+async function getGitStatus(cwd) {
+  const result = await execa("git", ["status", "--short"], { cwd, reject: false });
+  return result.exitCode === 0 ? result.stdout : "";
+}
+async function getGitDiffStat(cwd) {
+  const result = await execa("git", ["diff", "--stat"], { cwd, reject: false });
+  return result.exitCode === 0 ? result.stdout : "";
+}
+async function parseGitStatus(status) {
+  return status.split("\n").map((line) => line.trimEnd()).filter(Boolean).map((line) => ({
+    status: line.slice(0, 2).trim() || "?",
+    path: line.slice(3).trim()
+  }));
+}
+
+// src/core/safety.ts
+import path7 from "path";
+function relative(cwd, file) {
+  return path7.relative(cwd, file).replaceAll(path7.sep, "/");
+}
+async function detectRiskFiles(cwd) {
+  const files = (await listFilesRecursive(cwd)).map((file) => relative(cwd, file));
+  const includes = (needles) => files.filter((file) => needles.some((needle) => file.toLowerCase().includes(needle)));
+  return {
+    migrations: includes(["migration", "migrations/"]),
+    auth: includes(["auth", "oauth", "session", "passport"]),
+    security: includes(["security", "crypto", "secret", "permission", "policy"]),
+    billing: includes(["billing", "stripe", "payment", "invoice"]),
+    deployment: files.filter(
+      (file) => /(^|\/)(Dockerfile|docker-compose|vercel\.json|netlify\.toml|fly\.toml|render\.yaml|\.github\/workflows\/)/i.test(
+        file
+      )
+    ),
+    lockfiles: files.filter(
+      (file) => ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lock", "bun.lockb"].includes(
+        path7.basename(file)
+      )
+    ),
+    envFiles: files.filter((file) => /^\.env($|\.)|\/\.env($|\.)/.test(file))
+  };
+}
+
+// src/core/doctor.ts
+function check(name, status, message) {
+  return { name, status, message };
+}
+async function runDoctor(options) {
+  const cwd = options.cwd;
+  const checks = [];
+  checks.push(check("Current directory", "pass", cwd));
+  const gitInstalled = await commandExists("git");
+  checks.push(
+    check(
+      "Git installed",
+      gitInstalled ? "pass" : "warn",
+      gitInstalled ? "git is available" : "git not found"
+    )
+  );
+  const inGit = gitInstalled ? await isInsideGitRepo(cwd) : false;
+  checks.push(
+    check(
+      "Git repository",
+      inGit ? "pass" : "warn",
+      inGit ? "inside a git repo" : "not inside a git repo"
+    )
+  );
+  const status = inGit ? await getGitStatus(cwd) : "";
+  checks.push(
+    check(
+      "Working tree",
+      status.trim() ? "warn" : "pass",
+      status.trim() ? "working tree has changes" : "clean"
+    )
+  );
+  for (const file of ["AGENTS.md", "AGENTLOOP.md", ".agentloop"]) {
+    const exists = await pathExists(path8.join(cwd, file));
+    checks.push(check(file, exists ? "pass" : "warn", exists ? "found" : "missing"));
+  }
+  try {
+    await loadAgentLoopConfig(cwd);
+    checks.push(check(CONFIG_FILE, "pass", "valid"));
+  } catch (error) {
+    checks.push(
+      check(CONFIG_FILE, "fail", error instanceof Error ? error.message : "invalid config")
+    );
+  }
+  const agents = await readTextIfExists(path8.join(cwd, "AGENTS.md"));
+  if (agents && !agents.includes("AgentLoopKit")) {
+    checks.push(
+      check("AGENTS.md AgentLoopKit section", "warn", "AGENTS.md does not mention AgentLoopKit")
+    );
+  }
+  const packageManager = await detectPackageManager(cwd);
+  const projectType = await detectProjectType(cwd);
+  const commands = await detectPackageScripts(cwd, packageManager);
+  checks.push(check("Package manager", "pass", packageManager));
+  checks.push(check("Project type", "pass", projectType));
+  for (const key of ["test", "lint", "typecheck", "build"]) {
+    checks.push(
+      check(`${key} command`, commands[key] ? "pass" : "warn", commands[key] || "not detected")
+    );
+  }
+  const risks = await detectRiskFiles(cwd);
+  const riskCount = Object.values(risks).reduce((count, files) => count + files.length, 0);
+  checks.push(
+    check(
+      "Potential risk files",
+      riskCount ? "warn" : "pass",
+      riskCount ? `${riskCount} risk file(s) detected` : "none detected"
+    )
+  );
+  if (!commands.test) {
+    checks.push(check("Tests", "warn", "no test command detected"));
+  }
+  const warnings = checks.filter((item) => item.status === "warn");
+  const serious = checks.filter((item) => item.status === "fail");
+  const markdown = `# AgentLoopKit Doctor
+
+${checks.map((item) => {
+    const icon = item.status === "pass" ? "[pass]" : item.status === "warn" ? "[warn]" : "[fail]";
+    return `- ${icon} ${item.name}: ${item.message}`;
+  }).join("\n")}
+`;
+  return { checks, warnings, serious, markdown };
+}
+
+// src/cli/commands/doctor.ts
+function doctorCommand() {
+  return new Command2("doctor").description("Check whether this repo is ready for agentic engineering").option("--json", "print machine-readable output").action(async (options) => {
+    const result = await runDoctor({ cwd: process.cwd() });
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(result.markdown);
+    }
+    if (result.serious.length > 0) process.exitCode = 1;
+  });
+}
+
+// src/cli/commands/create-task.ts
+import { Command as Command3 } from "commander";
+import prompts from "prompts";
+
+// src/core/task-contract.ts
+import path9 from "path";
+
+// src/core/dates.ts
+function pad(value) {
+  return String(value).padStart(2, "0");
+}
+function formatDate(date = /* @__PURE__ */ new Date()) {
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+function formatTimestamp(date = /* @__PURE__ */ new Date()) {
+  return `${formatDate(date)}-${pad(date.getHours())}-${pad(date.getMinutes())}`;
+}
+
+// src/core/slug.ts
+function slugify(value) {
+  const slug = value.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+  return slug || "task";
+}
+
+// src/core/task-contract.ts
+function list(values, fallback = "None recorded yet.") {
+  const clean = values?.map((value) => value.trim()).filter(Boolean) ?? [];
+  if (clean.length === 0) return `- ${fallback}`;
+  return clean.map((value) => `- ${value}`).join("\n");
+}
+function generateTaskContract(input) {
+  const createdDate = input.createdDate ?? formatDate();
+  return `# ${input.title}
+
+- Created date: ${createdDate}
+- Task type: ${input.type}
+- Status: proposed
+
+## Problem Statement
+${input.problemStatement || "Describe the problem this task should solve."}
+
+## Desired Outcome
+${input.desiredOutcome || "Describe the concrete result expected from this task."}
+
+## Constraints
+${list(input.constraints)}
+
+## Non-Goals
+${list(input.nonGoals)}
+
+## Assumptions
+${list(input.assumptions)}
+
+## Likely Files or Areas
+${list(input.likelyFiles)}
+
+## Files or Areas Not to Touch
+${list(input.forbiddenFiles)}
+
+## Acceptance Criteria
+${list(input.acceptanceCriteria, "Add acceptance criteria before implementation starts.")}
+
+## Verification Commands
+${list(input.verificationCommands, "No verification command recorded.")}
+
+## Implementation Plan
+- Inspect relevant files before editing.
+- Keep changes focused on this contract.
+- Record any architecture decision in DECISIONS.md.
+
+## Risk Notes
+- Re-check protected areas before changing migrations, auth, secrets, billing, deployment, or public APIs.
+
+## Rollback Notes
+${input.rollbackNotes || "Document how to revert or disable this change."}
+
+## Handoff Requirements
+- Summarize files changed.
+- Include verification commands and results.
+- State unverified areas honestly.
+- Include risks, rollback notes, and reviewer checklist.
+`;
+}
+async function createTaskContractFile(options) {
+  const createdDate = options.input.createdDate ?? formatDate();
+  const relativePath = options.out ?? path9.join(options.config.paths.tasksDir, `${createdDate}-${slugify(options.input.title)}.md`);
+  const absolutePath = path9.isAbsolute(relativePath) ? relativePath : path9.join(options.cwd, relativePath);
+  const markdown = generateTaskContract({ ...options.input, createdDate });
+  await writeTextFile(absolutePath, markdown);
+  return { path: absolutePath, markdown };
+}
+
+// src/cli/commands/create-task.ts
+function lines(value) {
+  return value ? value.split("\n").map((line) => line.trim()).filter(Boolean) : [];
+}
+async function collectInteractive(initial) {
+  const answers = await prompts([
+    {
+      type: initial.title ? null : "text",
+      name: "title",
+      message: "Task title"
+    },
+    {
+      type: initial.type ? null : "select",
+      name: "type",
+      message: "Task type",
+      choices: TASK_TYPES.map((type) => ({ title: type, value: type }))
+    },
+    { type: "text", name: "problemStatement", message: "Problem statement" },
+    { type: "text", name: "desiredOutcome", message: "Desired outcome" },
+    { type: "text", name: "constraints", message: "Constraints (separate with semicolons)" },
+    { type: "text", name: "nonGoals", message: "Non-goals (separate with semicolons)" },
+    {
+      type: "text",
+      name: "likelyFiles",
+      message: "Likely files or areas (separate with semicolons)"
+    },
+    {
+      type: "text",
+      name: "forbiddenFiles",
+      message: "Files or areas not to touch (separate with semicolons)"
+    },
+    {
+      type: "text",
+      name: "acceptanceCriteria",
+      message: "Acceptance criteria (separate with semicolons)"
+    },
+    {
+      type: "text",
+      name: "verificationCommands",
+      message: "Verification commands (separate with semicolons)"
+    },
+    { type: "text", name: "rollbackNotes", message: "Rollback notes" }
+  ]);
+  return {
+    title: initial.title ?? answers.title,
+    type: initial.type ?? answers.type,
+    problemStatement: answers.problemStatement,
+    desiredOutcome: answers.desiredOutcome,
+    constraints: String(answers.constraints ?? "").split(";").filter(Boolean),
+    nonGoals: String(answers.nonGoals ?? "").split(";").filter(Boolean),
+    likelyFiles: String(answers.likelyFiles ?? "").split(";").filter(Boolean),
+    forbiddenFiles: String(answers.forbiddenFiles ?? "").split(";").filter(Boolean),
+    acceptanceCriteria: String(answers.acceptanceCriteria ?? "").split(";").filter(Boolean),
+    verificationCommands: String(answers.verificationCommands ?? "").split(";").filter(Boolean),
+    rollbackNotes: answers.rollbackNotes
+  };
+}
+function createTaskCommand() {
+  return new Command3("create-task").description("Create a task contract for an agentic coding session").option("--title <title>", "task title").option("--type <type>", "task type").option("--out <path>", "output file path").option("--problem <text>", "problem statement").option("--outcome <text>", "desired outcome").option("--constraint <text>", "constraint; repeat or use newlines", lines, []).option("--non-goal <text>", "non-goal; repeat or use newlines", lines, []).option("--acceptance <text>", "acceptance criterion; repeat or use newlines", lines, []).option("--verify-command <command>", "verification command; repeat or use newlines", lines, []).action(async (options) => {
+    const type = typeof options.type === "string" && TASK_TYPES.includes(options.type) ? options.type : void 0;
+    const title = typeof options.title === "string" ? options.title : void 0;
+    const config = await loadAgentLoopConfig(process.cwd());
+    const input = title && type ? {
+      title,
+      type,
+      problemStatement: String(options.problem ?? ""),
+      desiredOutcome: String(options.outcome ?? ""),
+      constraints: options.constraint,
+      nonGoals: options.nonGoal,
+      acceptanceCriteria: options.acceptance,
+      verificationCommands: options.verifyCommand
+    } : await collectInteractive({ title, type });
+    const result = await createTaskContractFile({
+      cwd: process.cwd(),
+      config,
+      input,
+      out: typeof options.out === "string" ? options.out : void 0
+    });
+    console.log(`Task contract created: ${result.path}`);
+  });
+}
+
+// src/cli/commands/verify.ts
+import { Command as Command4 } from "commander";
+
+// src/core/verification.ts
+import path10 from "path";
+import { execa as execa2 } from "execa";
+function excerpt(output, limit = 5e3) {
+  if (output.length <= limit) return output;
+  return `${output.slice(0, limit)}
+
+[output truncated to ${limit} characters]`;
+}
+function commandEntries(config, options) {
+  const configured = [
+    ["test", config.commands.test],
+    ["lint", config.commands.lint],
+    ["typecheck", config.commands.typecheck],
+    ["build", config.commands.build]
+  ];
+  const active = configured.filter(([key, command]) => {
+    if (key === "custom") return false;
+    return command && !options.skip?.[key];
+  });
+  for (const command of options.customCommands ?? []) {
+    if (command.trim()) active.push(["custom", command.trim()]);
+  }
+  return active;
+}
+async function runVerification(options) {
+  const timestamp = options.reportTimestamp ?? formatTimestamp();
+  const nowIso = options.nowIso ?? (/* @__PURE__ */ new Date()).toISOString();
+  const commands = commandEntries(options.config, options);
+  const notRun = [
+    ...["test", "lint", "typecheck", "build"].filter((key) => {
+      if (options.skip?.[key]) return true;
+      return !options.config.commands[key];
+    })
+  ];
+  const results = [];
+  for (const [key, command] of commands) {
+    const result = await execa2(command, {
+      cwd: options.cwd,
+      shell: true,
+      all: true,
+      reject: false,
+      env: { ...process.env, FORCE_COLOR: "0" }
+    });
+    results.push({
+      key,
+      command,
+      exitCode: result.exitCode ?? 1,
+      passed: result.exitCode === 0,
+      output: result.all ?? result.stdout ?? result.stderr ?? ""
+    });
+  }
+  const overallStatus = results.length === 0 ? "not-run" : results.every((result) => result.passed) ? "pass" : "fail";
+  const reportPath = path10.join(
+    options.cwd,
+    options.config.paths.reportsDir,
+    `${timestamp}-verification-report.md`
+  );
+  const branch = await getGitBranch(options.cwd);
+  const commit = await getGitCommit(options.cwd);
+  const status = await getGitStatus(options.cwd);
+  const markdown = `# Verification Report
+
+- Timestamp: ${nowIso}
+- Repo: ${path10.basename(options.cwd)}
+- Git branch: ${branch || "not available"}
+- Git commit: ${commit || "not available"}
+- Working tree: ${status.trim() ? "dirty" : "clean or unavailable"}
+- Overall status: ${overallStatus}
+
+## Commands Run
+${results.length === 0 ? "No verification commands were configured or selected." : results.map(
+    (result) => `### ${result.key}: \`${result.command}\`
+
+- Exit code: ${result.exitCode}
+- Status: ${result.passed ? "pass" : "fail"}
+
+\`\`\`text
+${excerpt(result.output || "(no output)")}
+\`\`\``
+  ).join("\n\n")}
+
+## Not Run
+${notRun.length ? notRun.map((item) => `- ${item}`).join("\n") : "- Nothing skipped."}
+
+## Recommended Next Actions
+${overallStatus === "pass" ? "- Review the diff and prepare a handoff summary." : overallStatus === "fail" ? "- Fix failing commands before claiming completion." : "- Add test, lint, typecheck, or build commands to agentloop.config.json."}
+`;
+  await writeTextFile(reportPath, markdown);
+  return { overallStatus, commands: results, notRun, markdown, reportPath };
+}
+
+// src/cli/commands/verify.ts
+function collect(value, previous) {
+  previous.push(value);
+  return previous;
+}
+function verifyCommand() {
+  return new Command4("verify").description("Run configured verification commands and write a report").option("--task <path>", "task contract path for humans to cross-reference").option("--json", "print machine-readable output").option("--no-build", "skip build command").option("--no-test", "skip test command").option("--no-lint", "skip lint command").option("--no-typecheck", "skip typecheck command").option("--command <command>", "custom command to run", collect, []).action(async (options) => {
+    const config = await loadAgentLoopConfig(process.cwd());
+    const result = await runVerification({
+      cwd: process.cwd(),
+      config,
+      skip: {
+        build: options.build === false,
+        test: options.test === false,
+        lint: options.lint === false,
+        typecheck: options.typecheck === false
+      },
+      customCommands: options.command
+    });
+    if (options.json) console.log(JSON.stringify(result, null, 2));
+    else
+      console.log(
+        `Verification report written: ${result.reportPath}
+Overall status: ${result.overallStatus}`
+      );
+    if (result.overallStatus === "fail") process.exitCode = 1;
+  });
+}
+
+// src/cli/commands/summarize.ts
+import { Command as Command5 } from "commander";
+
+// src/core/pr-summary.ts
+import path11 from "path";
+import { readdir as readdir4, readFile as readFile6 } from "fs/promises";
+function extractLine(markdown, pattern, fallback) {
+  if (!markdown) return fallback;
+  const match = markdown.match(pattern);
+  return match?.[1]?.trim() || fallback;
+}
+function generatePrSummary(input) {
+  const taskTitle = extractLine(input.taskMarkdown, /^#\s+(.+)$/m, "No task contract found.");
+  const verification = extractLine(
+    input.verificationMarkdown,
+    /Overall status:\s*([a-z-]+)/i,
+    "No verification report found."
+  );
+  const verificationLine = verification === "No verification report found." ? verification : `Overall status: ${verification}`;
+  const markdown = `# PR Summary
+
+- Generated: ${input.timestamp}
+- Task context: ${taskTitle}
+- Verification status: ${verificationLine}
+
+## Summary
+This summary was generated deterministically from git status, the latest task contract, and the latest verification report.
+
+## Changed Files
+${input.changedFiles.length ? input.changedFiles.map((file) => `- ${file.status} \`${file.path}\``).join("\n") : "- No changed files detected."}
+
+## Diff Stats
+${input.diffStat?.trim() || "No diff stats available."}
+
+## Behaviour Changed
+- Review changed files and task contract to confirm intended behavior.
+
+## Verification Performed
+- ${verificationLine}
+
+## Verification Not Performed
+- Check the verification report for skipped commands.
+
+## Risks
+- Re-check protected files such as migrations, secrets, auth, billing, deployment, and public APIs before merge.
+
+## Rollback Notes
+- Revert the changed files or revert the merge commit if this lands as a PR.
+
+## Reviewer Checklist
+- [ ] Acceptance criteria match the task contract.
+- [ ] Verification evidence is adequate for the change.
+- [ ] Risk areas have been reviewed.
+- [ ] Rollback plan is clear.
+
+## Follow-Ups
+- Capture any deferred work in ROADMAP.md or a new task contract.
+`;
+  return { markdown };
+}
+async function latestMarkdownFile(dir) {
+  if (!await pathExists(dir)) return void 0;
+  const entries = (await readdir4(dir, { withFileTypes: true })).filter(
+    (entry) => entry.isFile() && entry.name.endsWith(".md") && entry.name.toLowerCase() !== "readme.md"
+  ).map((entry) => entry.name).sort();
+  const latest = entries.at(-1);
+  return latest ? path11.join(dir, latest) : void 0;
+}
+async function summarizeRepository(options) {
+  const timestamp = options.timestamp ?? formatTimestamp();
+  const status = await getGitStatus(options.cwd);
+  const changedFiles = await parseGitStatus(status);
+  const diffStat = await getGitDiffStat(options.cwd);
+  const taskPath = options.taskPath ?? await latestMarkdownFile(path11.join(options.cwd, options.config.paths.tasksDir));
+  const reportPath = options.reportPath ?? await latestMarkdownFile(path11.join(options.cwd, options.config.paths.reportsDir));
+  const taskMarkdown = taskPath && await pathExists(taskPath) ? await readFile6(taskPath, "utf8") : void 0;
+  const verificationMarkdown = reportPath && await pathExists(reportPath) ? await readFile6(reportPath, "utf8") : void 0;
+  const summary = generatePrSummary({
+    timestamp,
+    status,
+    changedFiles,
+    taskMarkdown,
+    verificationMarkdown,
+    diffStat
+  });
+  const outPath = path11.join(
+    options.cwd,
+    options.config.paths.handoffsDir,
+    `${timestamp}-pr-summary.md`
+  );
+  if (options.write) await writeTextFile(outPath, summary.markdown);
+  return { ...summary, outPath, changedFiles };
+}
+
+// src/cli/commands/summarize.ts
+function summarizeCommand() {
+  return new Command5("summarize").description("Generate a deterministic PR/reviewer summary").option("--task <path>", "task contract path").option("--report <path>", "verification report path").option("--format <format>", "markdown or json", "markdown").option("--write", "write summary to .agentloop/handoffs").option("--json", "print JSON output").action(async (options) => {
+    const config = await loadAgentLoopConfig(process.cwd());
+    const result = await summarizeRepository({
+      cwd: process.cwd(),
+      config,
+      taskPath: typeof options.task === "string" ? options.task : void 0,
+      reportPath: typeof options.report === "string" ? options.report : void 0,
+      write: Boolean(options.write)
+    });
+    if (options.json || options.format === "json") {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(result.markdown);
+      if (options.write) console.log(`
+Summary written: ${result.outPath}`);
+    }
+  });
+}
+
+// src/cli/commands/install-agent.ts
+import { Command as Command6 } from "commander";
+
+// src/core/agent-installation.ts
+import path12 from "path";
+function isSupportedAgent(value) {
+  return SUPPORTED_AGENTS.includes(value);
+}
+var displayNames = {
+  codex: "Codex",
+  "claude-code": "Claude Code",
+  cursor: "Cursor",
+  opencode: "OpenCode",
+  "gemini-cli": "Gemini CLI",
+  "github-copilot-cli": "GitHub Copilot CLI",
+  generic: "Generic Coding Agent"
+};
+async function installAgentInstructions(options) {
+  const agentFilePath = path12.join(options.cwd, ".agentloop", "agents", `${options.agent}.md`);
+  const content = await readTemplate(`agents/${options.agent}.md`, {
+    agentName: displayNames[options.agent]
+  });
+  await writeTextFile(agentFilePath, content);
+  const agentsPath = path12.join(options.cwd, "AGENTS.md");
+  const existing = await readTextIfExists(agentsPath);
+  const marker = `<!-- agentloopkit-agent:${options.agent} -->`;
+  if (!existing.includes(marker)) {
+    const block = `
+
+${marker}
+## AgentLoopKit: ${displayNames[options.agent]}
+
+- Agent instructions: .agentloop/agents/${options.agent}.md
+- Read AGENTLOOP.md before changing code.
+- Use task contracts, verification reports, and handoff summaries.
+<!-- /agentloopkit-agent:${options.agent} -->
+`;
+    await writeTextFile(
+      agentsPath,
+      existing ? `${existing.trimEnd()}
+${block}` : block.trimStart()
+    );
+  }
+  return { agentFilePath, agentsPath };
+}
+async function installAllAgentInstructions(options) {
+  const results = [];
+  for (const agent of SUPPORTED_AGENTS) {
+    results.push(await installAgentInstructions({ cwd: options.cwd, agent }));
+  }
+  return results;
+}
+
+// src/cli/commands/install-agent.ts
+function installAgentCommand() {
+  return new Command6("install-agent").description("Install agent-specific instruction files").argument("<agent>", `one of: ${SUPPORTED_AGENTS.join(", ")}, all`).action(async (agent) => {
+    if (agent === "all") {
+      const results = await installAllAgentInstructions({ cwd: process.cwd() });
+      console.log(`Agent instructions written: ${results.length}`);
+      console.log("AGENTS.md now references all bundled agent instructions.");
+      return;
+    }
+    if (!isSupportedAgent(agent)) {
+      throw new Error(
+        `Unsupported agent "${agent}". Supported agents: ${SUPPORTED_AGENTS.join(", ")}, all`
+      );
+    }
+    const result = await installAgentInstructions({ cwd: process.cwd(), agent });
+    console.log(`Agent instructions written: ${result.agentFilePath}`);
+    console.log("AGENTS.md now references the agent instructions.");
+  });
+}
+
+// src/cli/commands/list-templates.ts
+import { Command as Command7 } from "commander";
+function listTemplatesCommand() {
+  return new Command7("list-templates").description("List available AgentLoopKit templates").action(async () => {
+    const templates = await listTemplateFiles();
+    for (const [group, files] of Object.entries(templates)) {
+      console.log(`${group}:`);
+      for (const file of files) console.log(`  - ${file}`);
+    }
+  });
+}
+
+// src/cli/commands/version.ts
+import { Command as Command8 } from "commander";
+function versionCommand() {
+  return new Command8("version").description("Print CLI version").action(() => {
+    console.log("0.1.0");
+  });
+}
+
+// src/cli/index.ts
+var program = new Command9();
+program.name("agentloop").description("A drop-in engineering loop for coding agents.").version("0.1.0", "-V, --version", "print CLI version");
+program.addCommand(initCommand());
+program.addCommand(doctorCommand());
+program.addCommand(createTaskCommand());
+program.addCommand(verifyCommand());
+program.addCommand(summarizeCommand());
+program.addCommand(installAgentCommand());
+program.addCommand(listTemplatesCommand());
+program.addCommand(versionCommand());
+program.parseAsync(process.argv).catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`agentloop: ${message}`);
+  process.exitCode = 1;
+});
+//# sourceMappingURL=index.js.map