autohand-cli 0.6.11 → 0.7.2

package/dist/AutomodeManager-FQQPBHAD.js

@@ -0,0 +1,1422 @@
+import "./chunk-3RG5ZIWI.js";
+
+// src/core/AutomodeManager.ts
+import { EventEmitter } from "events";
+import { execSync } from "child_process";
+import path5 from "path";
+import chalk from "chalk";
+import crypto from "crypto";
+
+// src/core/AutomodeState.ts
+import fs from "fs-extra";
+import path from "path";
+var STATE_FILE_PATH = ".autohand/automode.local.md";
+var DEFAULT_THRESHOLDS = {
+  noProgress: 3,
+  sameError: 5,
+  testOnly: 3
+};
+var AutomodeState = class {
+  constructor(workspaceRoot) {
+    this.state = null;
+    this.iterations = [];
+    this.circuitBreaker = {
+      noProgressCount: 0,
+      sameErrorCount: 0,
+      testOnlyCount: 0
+    };
+    this.workspaceRoot = workspaceRoot;
+  }
+  /**
+   * Get the state file path
+   */
+  getStatePath() {
+    return path.join(this.workspaceRoot, STATE_FILE_PATH);
+  }
+  /**
+   * Check if an auto-mode session is active
+   */
+  async hasActiveSession() {
+    try {
+      const exists = await fs.pathExists(this.getStatePath());
+      if (!exists) return false;
+      const state = await this.load();
+      return state !== null && state.status === "running";
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Initialize a new auto-mode session
+   */
+  async initialize(options) {
+    this.state = {
+      sessionId: options.sessionId,
+      prompt: options.prompt,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      currentIteration: 0,
+      maxIterations: options.maxIterations,
+      status: "running",
+      branch: options.branch,
+      worktreePath: options.worktreePath,
+      filesCreated: 0,
+      filesModified: 0,
+      completionPromise: options.completionPromise
+    };
+    this.iterations = [];
+    this.circuitBreaker = {
+      noProgressCount: 0,
+      sameErrorCount: 0,
+      testOnlyCount: 0
+    };
+    await this.save();
+    return this.state;
+  }
+  /**
+   * Load state from file
+   */
+  async load() {
+    try {
+      const filePath = this.getStatePath();
+      if (!await fs.pathExists(filePath)) {
+        return null;
+      }
+      const content = await fs.readFile(filePath, "utf-8");
+      const state = this.parseStateMarkdown(content);
+      this.state = state;
+      return state;
+    } catch (error) {
+      console.error("[automode] Failed to load state:", error);
+      return null;
+    }
+  }
+  /**
+   * Save state to file
+   */
+  async save() {
+    if (!this.state) return;
+    try {
+      const filePath = this.getStatePath();
+      await fs.ensureDir(path.dirname(filePath));
+      const content = this.formatStateMarkdown(this.state);
+      await fs.writeFile(filePath, content, "utf-8");
+    } catch (error) {
+      console.error("[automode] Failed to save state:", error);
+    }
+  }
+  /**
+   * Get current state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Get all iteration logs
+   */
+  getIterations() {
+    return [...this.iterations];
+  }
+  /**
+   * Update iteration count and track actions
+   */
+  async recordIteration(log) {
+    if (!this.state) return;
+    this.state.currentIteration += 1;
+    const iterationLog = {
+      ...log,
+      iteration: this.state.currentIteration
+    };
+    this.iterations.push(iterationLog);
+    await this.save();
+  }
+  /**
+   * Record a checkpoint (git commit)
+   */
+  async recordCheckpoint(commit, message) {
+    if (!this.state) return;
+    this.state.lastCheckpoint = {
+      commit,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (this.iterations.length > 0) {
+      const lastIteration = this.iterations[this.iterations.length - 1];
+      lastIteration.checkpoint = { commit, message };
+    }
+    await this.save();
+  }
+  /**
+   * Update file counts
+   */
+  async updateFileCounts(created, modified) {
+    if (!this.state) return;
+    this.state.filesCreated += created;
+    this.state.filesModified += modified;
+    await this.save();
+  }
+  /**
+   * Update status
+   */
+  async setStatus(status, reason, errorMessage) {
+    if (!this.state) return;
+    this.state.status = status;
+    if (reason) {
+      this.state.cancelReason = reason;
+    }
+    if (errorMessage) {
+      this.state.errorMessage = errorMessage;
+    }
+    await this.save();
+  }
+  /**
+   * Check and update circuit breaker state
+   * Returns true if circuit breaker should trigger
+   */
+  checkCircuitBreaker(hasFileChanges, errorHash, isTestOnly, thresholds = DEFAULT_THRESHOLDS) {
+    if (!hasFileChanges) {
+      this.circuitBreaker.noProgressCount += 1;
+      if (this.circuitBreaker.noProgressCount >= thresholds.noProgress) {
+        return {
+          triggered: true,
+          reason: `No file changes for ${this.circuitBreaker.noProgressCount} consecutive iterations`
+        };
+      }
+    } else {
+      this.circuitBreaker.noProgressCount = 0;
+    }
+    if (errorHash) {
+      if (this.circuitBreaker.lastErrorHash === errorHash) {
+        this.circuitBreaker.sameErrorCount += 1;
+        if (this.circuitBreaker.sameErrorCount >= thresholds.sameError) {
+          return {
+            triggered: true,
+            reason: `Same error for ${this.circuitBreaker.sameErrorCount} consecutive iterations`
+          };
+        }
+      } else {
+        this.circuitBreaker.sameErrorCount = 1;
+        this.circuitBreaker.lastErrorHash = errorHash;
+      }
+    } else {
+      this.circuitBreaker.sameErrorCount = 0;
+      this.circuitBreaker.lastErrorHash = void 0;
+    }
+    if (isTestOnly) {
+      this.circuitBreaker.testOnlyCount += 1;
+      if (this.circuitBreaker.testOnlyCount >= thresholds.testOnly) {
+        return {
+          triggered: true,
+          reason: `Only running tests for ${this.circuitBreaker.testOnlyCount} consecutive iterations`
+        };
+      }
+    } else {
+      this.circuitBreaker.testOnlyCount = 0;
+    }
+    return { triggered: false };
+  }
+  /**
+   * Check if completion promise is in the output
+   */
+  checkCompletionPromise(output) {
+    if (!this.state) return false;
+    const promise = this.state.completionPromise;
+    return output.includes(promise) || output.includes(`<promise>${promise}</promise>`);
+  }
+  /**
+   * Clean up state file after session ends
+   */
+  async cleanup() {
+    try {
+      const filePath = this.getStatePath();
+      if (await fs.pathExists(filePath)) {
+        if (this.state && this.state.status === "running") {
+          this.state.status = "cancelled";
+          this.state.cancelReason = "error";
+          await this.save();
+        }
+      }
+    } catch (error) {
+      console.error("[automode] Failed to cleanup state:", error);
+    }
+  }
+  /**
+   * Parse state from markdown format
+   */
+  parseStateMarkdown(content) {
+    try {
+      const getValue = (key) => {
+        const regex = new RegExp(`\\*\\*${key}:\\*\\*\\s*(.+)`, "i");
+        const match = content.match(regex);
+        return match?.[1]?.trim();
+      };
+      const sessionId = getValue("Session ID") ?? getValue("sessionId");
+      const prompt = getValue("Prompt");
+      const startedAt = getValue("Started");
+      const currentIteration = parseInt(getValue("Current Iteration") ?? "0", 10);
+      const maxIterations = parseInt(getValue("Max Iterations") ?? "50", 10);
+      const status = getValue("Status") ?? "running";
+      const branch = getValue("Branch");
+      const worktreePath = getValue("Worktree");
+      const filesCreated = parseInt(getValue("Files Created") ?? "0", 10);
+      const filesModified = parseInt(getValue("Files Modified") ?? "0", 10);
+      const completionPromise = getValue("Completion Promise") ?? "DONE";
+      if (!sessionId || !prompt || !startedAt) {
+        return null;
+      }
+      return {
+        sessionId,
+        prompt,
+        startedAt,
+        currentIteration,
+        maxIterations,
+        status,
+        branch,
+        worktreePath,
+        filesCreated,
+        filesModified,
+        completionPromise
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Format state as markdown
+   */
+  formatStateMarkdown(state) {
+    const lines = [
+      "# Auto-Mode State",
+      "",
+      "## Session",
+      `- **Session ID:** ${state.sessionId}`,
+      `- **Started:** ${state.startedAt}`,
+      `- **Prompt:** ${state.prompt}`
+    ];
+    if (state.branch) {
+      lines.push(`- **Branch:** ${state.branch}`);
+    }
+    if (state.worktreePath) {
+      lines.push(`- **Worktree:** ${state.worktreePath}`);
+    }
+    lines.push(
+      "",
+      "## Progress",
+      `- **Current Iteration:** ${state.currentIteration}`,
+      `- **Max Iterations:** ${state.maxIterations}`,
+      `- **Status:** ${state.status}`,
+      "",
+      "## Metrics",
+      `- **Files Created:** ${state.filesCreated}`,
+      `- **Files Modified:** ${state.filesModified}`
+    );
+    if (state.lastCheckpoint) {
+      lines.push(
+        "",
+        "## Last Checkpoint",
+        `- **Commit:** ${state.lastCheckpoint.commit}`,
+        `- **Message:** ${state.lastCheckpoint.message}`,
+        `- **Timestamp:** ${state.lastCheckpoint.timestamp}`
+      );
+    }
+    lines.push(
+      "",
+      "## Settings",
+      `- **Completion Promise:** ${state.completionPromise}`
+    );
+    if (state.cancelReason) {
+      lines.push(`- **Cancel Reason:** ${state.cancelReason}`);
+    }
+    if (state.errorMessage) {
+      lines.push(`- **Error:** ${state.errorMessage}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+};
+function hashError(error) {
+  return error.slice(0, 100).toLowerCase().replace(/\s+/g, " ").trim();
+}
+
+// src/core/AutomodeChangelog.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+var CHANGELOG_FILE = "AUTOMODE_CHANGELOG.md";
+var STATUS_EMOJI = {
+  running: "\u{1F504}",
+  paused: "\u23F8\uFE0F",
+  completed: "\u2705",
+  cancelled: "\u26A0\uFE0F",
+  failed: "\u274C"
+};
+var STATUS_TEXT = {
+  running: "Running",
+  paused: "Paused",
+  completed: "Completed successfully",
+  cancelled: "Cancelled",
+  failed: "Failed"
+};
+async function generateChangelog(workspaceRoot, state, iterations, gitCommits = []) {
+  const changelogPath = path2.join(workspaceRoot, CHANGELOG_FILE);
+  const startTime = new Date(state.startedAt);
+  const endTime = /* @__PURE__ */ new Date();
+  const durationMs = endTime.getTime() - startTime.getTime();
+  const durationMinutes = Math.round(durationMs / 6e4);
+  const totalTokens = iterations.reduce((sum, it) => sum + (it.tokensUsed ?? 0), 0);
+  const totalCost = iterations.reduce((sum, it) => sum + (it.cost ?? 0), 0);
+  const lines = [
+    "# Auto-Mode Session Report",
+    "",
+    "## Summary",
+    "",
+    `- **Task:** ${state.prompt.slice(0, 100)}${state.prompt.length > 100 ? "..." : ""}`,
+    `- **Duration:** ${durationMinutes} minutes (${state.currentIteration} iterations)`,
+    `- **Result:** ${STATUS_EMOJI[state.status]} ${STATUS_TEXT[state.status]}`
+  ];
+  if (state.branch) {
+    const merged = state.status === "completed" ? " \u2192 merged to main" : "";
+    lines.push(`- **Branch:** ${state.branch}${merged}`);
+  }
+  if (state.cancelReason && state.status !== "completed") {
+    lines.push(`- **Reason:** ${formatCancelReason(state.cancelReason)}`);
+  }
+  if (state.errorMessage) {
+    lines.push(`- **Error:** ${state.errorMessage}`);
+  }
+  lines.push("", "## Iterations", "");
+  for (const iteration of iterations) {
+    const time = new Date(iteration.timestamp).toLocaleTimeString();
+    lines.push(`### Iteration ${iteration.iteration} (${time})`);
+    lines.push("");
+    if (iteration.actions.length > 0) {
+      for (const action of iteration.actions) {
+        lines.push(`- ${action}`);
+      }
+    } else {
+      lines.push("- No actions recorded");
+    }
+    if (iteration.checkpoint) {
+      lines.push("");
+      lines.push(`**Checkpoint:** \`${iteration.checkpoint.commit}\` - "${iteration.checkpoint.message}"`);
+    }
+    if (iteration.tokensUsed) {
+      lines.push("");
+      lines.push(`*Tokens: ${iteration.tokensUsed.toLocaleString()}*`);
+    }
+    lines.push("");
+  }
+  lines.push("## Final State", "");
+  lines.push(`- **Files Created:** ${state.filesCreated}`);
+  lines.push(`- **Files Modified:** ${state.filesModified}`);
+  lines.push(`- **Total Iterations:** ${state.currentIteration}`);
+  if (totalTokens > 0) {
+    lines.push(`- **Total Tokens:** ${totalTokens.toLocaleString()}`);
+  }
+  if (totalCost > 0) {
+    lines.push(`- **Estimated Cost:** $${totalCost.toFixed(2)}`);
+  }
+  if (gitCommits.length > 0) {
+    lines.push("", "## Commits Made", "");
+    gitCommits.forEach((commit, index) => {
+      lines.push(`${index + 1}. \`${commit.hash}\` - ${commit.message}`);
+    });
+  }
+  lines.push("", "---", "");
+  lines.push(`*Generated by autohand auto-mode on ${endTime.toISOString()}*`);
+  lines.push("");
+  const content = lines.join("\n");
+  await fs2.writeFile(changelogPath, content, "utf-8");
+  return changelogPath;
+}
+function formatCancelReason(reason) {
+  const reasonMap = {
+    user_escape: "User pressed ESC",
+    user_cancel: "User cancelled via command",
+    hook_cancel: "Cancelled by hook",
+    rpc_cancel: "Cancelled via RPC",
+    acp_cancel: "Cancelled via ACP",
+    max_iterations: "Maximum iterations reached",
+    max_runtime: "Maximum runtime exceeded",
+    max_cost: "Maximum cost exceeded",
+    circuit_breaker: "Circuit breaker triggered",
+    completion: "Completion promise detected",
+    error: "Error occurred"
+  };
+  return reasonMap[reason] ?? reason;
+}
+
+// src/core/PatternDetector.ts
+import path3 from "path";
+import fs3 from "fs-extra";
+var PatternDetector = class {
+  constructor(workspaceRoot) {
+    this.workspaceRoot = workspaceRoot;
+  }
+  /**
+   * Detect all project patterns
+   */
+  async detect() {
+    const [techStack, commands, framework, packageManager] = await Promise.all([
+      this.detectTechStack(),
+      this.detectCommands(),
+      this.detectFramework(),
+      this.detectPackageManager()
+    ]);
+    return {
+      techStack,
+      testCommand: commands.test,
+      buildCommand: commands.build,
+      lintCommand: commands.lint,
+      framework,
+      packageManager
+    };
+  }
+  /**
+   * Detect tech stack from project files
+   */
+  async detectTechStack() {
+    const stack = [];
+    const packageJsonPath = path3.join(this.workspaceRoot, "package.json");
+    if (await fs3.pathExists(packageJsonPath)) {
+      try {
+        const pkg = await fs3.readJSON(packageJsonPath);
+        const allDeps = {
+          ...pkg.dependencies,
+          ...pkg.devDependencies
+        };
+        if (allDeps.typescript || await fs3.pathExists(path3.join(this.workspaceRoot, "tsconfig.json"))) {
+          stack.push("TypeScript");
+        } else {
+          stack.push("JavaScript");
+        }
+        if (allDeps.react) {
+          stack.push("React");
+        }
+        if (allDeps.vue) {
+          stack.push("Vue");
+        }
+        if (allDeps.svelte) {
+          stack.push("Svelte");
+        }
+        stack.push("Node.js");
+        if (allDeps.vitest) {
+          stack.push("Vitest");
+        } else if (allDeps.jest) {
+          stack.push("Jest");
+        } else if (allDeps.mocha) {
+          stack.push("Mocha");
+        }
+      } catch {
+      }
+    }
+    if (await fs3.pathExists(path3.join(this.workspaceRoot, "Cargo.toml"))) {
+      stack.push("Rust");
+    }
+    if (await fs3.pathExists(path3.join(this.workspaceRoot, "go.mod"))) {
+      stack.push("Go");
+    }
+    if (await fs3.pathExists(path3.join(this.workspaceRoot, "pyproject.toml")) || await fs3.pathExists(path3.join(this.workspaceRoot, "setup.py")) || await fs3.pathExists(path3.join(this.workspaceRoot, "requirements.txt"))) {
+      stack.push("Python");
+    }
+    if (await fs3.pathExists(path3.join(this.workspaceRoot, "pom.xml")) || await fs3.pathExists(path3.join(this.workspaceRoot, "build.gradle"))) {
+      stack.push("Java");
+    }
+    return stack;
+  }
+  /**
+   * Detect test, build, and lint commands from package.json scripts
+   */
+  async detectCommands() {
+    const commands = {};
+    const packageJsonPath = path3.join(this.workspaceRoot, "package.json");
+    if (await fs3.pathExists(packageJsonPath)) {
+      try {
+        const pkg = await fs3.readJSON(packageJsonPath);
+        const scripts = pkg.scripts ?? {};
+        const pm = await this.detectPackageManager();
+        const runCmd = pm === "bun" ? "bun" : pm === "yarn" ? "yarn" : pm === "pnpm" ? "pnpm" : "npm run";
+        if (scripts.test) {
+          commands.test = `${runCmd} test`;
+        }
+        if (scripts.build) {
+          commands.build = `${runCmd} build`;
+        }
+        if (scripts.lint) {
+          commands.lint = `${runCmd} lint`;
+        } else if (scripts.eslint) {
+          commands.lint = `${runCmd} eslint`;
+        }
+      } catch {
+      }
+    }
+    if (await fs3.pathExists(path3.join(this.workspaceRoot, "Makefile"))) {
+      try {
+        const makefile = await fs3.readFile(path3.join(this.workspaceRoot, "Makefile"), "utf-8");
+        if (!commands.test && makefile.includes("test:")) {
+          commands.test = "make test";
+        }
+        if (!commands.build && makefile.includes("build:")) {
+          commands.build = "make build";
+        }
+        if (!commands.lint && makefile.includes("lint:")) {
+          commands.lint = "make lint";
+        }
+      } catch {
+      }
+    }
+    if (await fs3.pathExists(path3.join(this.workspaceRoot, "Cargo.toml"))) {
+      if (!commands.test) commands.test = "cargo test";
+      if (!commands.build) commands.build = "cargo build";
+      if (!commands.lint) commands.lint = "cargo clippy";
+    }
+    if (await fs3.pathExists(path3.join(this.workspaceRoot, "go.mod"))) {
+      if (!commands.test) commands.test = "go test ./...";
+      if (!commands.build) commands.build = "go build";
+      if (!commands.lint) commands.lint = "golangci-lint run";
+    }
+    return commands;
+  }
+  /**
+   * Detect the main framework used
+   */
+  async detectFramework() {
+    const packageJsonPath = path3.join(this.workspaceRoot, "package.json");
+    if (await fs3.pathExists(packageJsonPath)) {
+      try {
+        const pkg = await fs3.readJSON(packageJsonPath);
+        const allDeps = {
+          ...pkg.dependencies,
+          ...pkg.devDependencies
+        };
+        if (allDeps.next) {
+          const version = allDeps.next.replace(/[^0-9.]/g, "").split(".")[0];
+          return `Next.js ${version}`;
+        }
+        if (allDeps["@remix-run/node"] || allDeps["@remix-run/react"]) {
+          return "Remix";
+        }
+        if (allDeps.astro) {
+          return "Astro";
+        }
+        if (allDeps.express) {
+          return "Express";
+        }
+        if (allDeps.fastify) {
+          return "Fastify";
+        }
+        if (allDeps["@nestjs/core"]) {
+          return "NestJS";
+        }
+        if (allDeps.hono) {
+          return "Hono";
+        }
+        if (allDeps.elysia) {
+          return "Elysia";
+        }
+      } catch {
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Detect the package manager used
+   */
+  async detectPackageManager() {
+    if (await fs3.pathExists(path3.join(this.workspaceRoot, "bun.lockb"))) {
+      return "bun";
+    }
+    if (await fs3.pathExists(path3.join(this.workspaceRoot, "pnpm-lock.yaml"))) {
+      return "pnpm";
+    }
+    if (await fs3.pathExists(path3.join(this.workspaceRoot, "yarn.lock"))) {
+      return "yarn";
+    }
+    if (await fs3.pathExists(path3.join(this.workspaceRoot, "package-lock.json"))) {
+      return "npm";
+    }
+    return "npm";
+  }
+};
+
+// src/core/AgentsMdUpdater.ts
+import path4 from "path";
+import fs4 from "fs-extra";
+var AgentsMdUpdater = class {
+  constructor(workspaceRoot) {
+    this.workspaceRoot = workspaceRoot;
+    this.agentsPath = path4.join(workspaceRoot, "AGENTS.md");
+  }
+  /**
+   * Update AGENTS.md with discovered patterns and skills
+   */
+  async update(options) {
+    const { patterns, usedSkills, conventions } = options;
+    let content = await this.loadOrCreateAgentsMd();
+    if (patterns) {
+      content = this.updateTechStackSection(content, patterns);
+      content = this.updateCommandsSection(content, patterns);
+    }
+    if (usedSkills && usedSkills.length > 0) {
+      content = this.updateSkillsSection(content, usedSkills);
+    }
+    if (conventions && conventions.length > 0) {
+      content = this.updateConventionsSection(content, conventions);
+    }
+    await fs4.writeFile(this.agentsPath, content, "utf-8");
+    return true;
+  }
+  /**
+   * Load existing AGENTS.md or create a new one
+   */
+  async loadOrCreateAgentsMd() {
+    if (await fs4.pathExists(this.agentsPath)) {
+      return await fs4.readFile(this.agentsPath, "utf-8");
+    }
+    return `# Project Autopilot
+
+This file is automatically updated by Autohand to help AI assistants understand your project.
+
+`;
+  }
+  /**
+   * Update the Tech Stack section
+   */
+  updateTechStackSection(content, patterns) {
+    if (patterns.techStack.length === 0) return content;
+    const techStackContent = patterns.techStack.map((tech) => `- ${tech}`).join("\n");
+    const sectionContent = `## Tech Stack
+
+${techStackContent}
+`;
+    return this.updateSection(content, "Tech Stack", sectionContent);
+  }
+  /**
+   * Update the Commands section
+   */
+  updateCommandsSection(content, patterns) {
+    const commands = [];
+    if (patterns.packageManager) {
+      commands.push(`- **Package Manager:** \`${patterns.packageManager}\``);
+    }
+    if (patterns.testCommand) {
+      commands.push(`- **Test:** \`${patterns.testCommand}\``);
+    }
+    if (patterns.buildCommand) {
+      commands.push(`- **Build:** \`${patterns.buildCommand}\``);
+    }
+    if (patterns.lintCommand) {
+      commands.push(`- **Lint:** \`${patterns.lintCommand}\``);
+    }
+    if (patterns.framework) {
+      commands.push(`- **Framework:** ${patterns.framework}`);
+    }
+    if (commands.length === 0) return content;
+    const sectionContent = `## Commands
+
+${commands.join("\n")}
+`;
+    return this.updateSection(content, "Commands", sectionContent);
+  }
+  /**
+   * Update the Skills section
+   */
+  updateSkillsSection(content, usedSkills) {
+    if (usedSkills.length === 0) return content;
+    const skillCounts = usedSkills.reduce((acc, skill) => {
+      acc[skill] = (acc[skill] || 0) + 1;
+      return acc;
+    }, {});
+    const skillsList = Object.entries(skillCounts).sort((a, b) => b[1] - a[1]).map(([skill, count]) => `- ${skill} (${count}x)`).join("\n");
+    const sectionContent = `## Skills Used
+
+${skillsList}
+`;
+    return this.updateSection(content, "Skills Used", sectionContent);
+  }
+  /**
+   * Update the Conventions section
+   */
+  updateConventionsSection(content, conventions) {
+    if (conventions.length === 0) return content;
+    const conventionsList = conventions.map((c) => `- ${c}`).join("\n");
+    const sectionContent = `## Conventions
+
+${conventionsList}
+`;
+    return this.updateSection(content, "Conventions", sectionContent);
+  }
+  /**
+   * Update or insert a section in the content
+   */
+  updateSection(content, sectionName, newSectionContent) {
+    const sectionRegex = new RegExp(
+      `## ${this.escapeRegex(sectionName)}[\\s\\S]*?(?=\\n## |$)`,
+      "g"
+    );
+    if (sectionRegex.test(content)) {
+      return content.replace(sectionRegex, newSectionContent.trim() + "\n");
+    }
+    const conventionsMatch = content.match(/\n## Conventions/);
+    if (conventionsMatch && conventionsMatch.index !== void 0) {
+      return content.slice(0, conventionsMatch.index) + "\n" + newSectionContent + "\n" + content.slice(conventionsMatch.index);
+    }
+    return content.trimEnd() + "\n\n" + newSectionContent;
+  }
+  /**
+   * Escape regex special characters
+   */
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  /**
+   * Check if AGENTS.md exists
+   */
+  async exists() {
+    return fs4.pathExists(this.agentsPath);
+  }
+  /**
+   * Get the detected patterns summary for display
+   */
+  static formatPatternsSummary(patterns) {
+    const parts = [];
+    if (patterns.techStack.length > 0) {
+      parts.push(`Tech: ${patterns.techStack.join(", ")}`);
+    }
+    if (patterns.framework) {
+      parts.push(`Framework: ${patterns.framework}`);
+    }
+    if (patterns.packageManager) {
+      parts.push(`PM: ${patterns.packageManager}`);
+    }
+    return parts.join(" | ") || "No patterns detected";
+  }
+};
+
+// src/core/AutomodeManager.ts
+var DEFAULTS = {
+  maxIterations: 50,
+  maxRuntime: 120,
+  // minutes
+  maxCost: 10,
+  // dollars
+  checkpointInterval: 5,
+  completionPromise: "DONE",
+  useWorktree: true,
+  noProgressThreshold: 3,
+  sameErrorThreshold: 5,
+  testOnlyThreshold: 3
+};
+var AutomodeManager = class extends EventEmitter {
+  constructor(config, workspaceRoot, hookManager, session, memoryManager) {
+    super();
+    this.abortController = null;
+    this.startTime = 0;
+    this.totalCost = 0;
+    this.worktreePath = null;
+    this.originalBranch = null;
+    this.branchName = null;
+    this.gitCommits = [];
+    this.isRunning = false;
+    this.isPaused = false;
+    this.config = config;
+    this.workspaceRoot = workspaceRoot;
+    this.hookManager = hookManager;
+    this.session = session;
+    this.memoryManager = memoryManager;
+    this.patternDetector = new PatternDetector(workspaceRoot);
+    this.agentsMdUpdater = new AgentsMdUpdater(workspaceRoot);
+    this.state = new AutomodeState(workspaceRoot);
+    this.settings = {
+      ...DEFAULTS,
+      ...config.automode
+    };
+  }
+  /**
+   * Check if auto-mode is currently running
+   */
+  isActive() {
+    return this.isRunning;
+  }
+  /**
+   * Check if auto-mode is paused
+   */
+  isPausedState() {
+    return this.isPaused;
+  }
+  /**
+   * Get current state
+   */
+  getState() {
+    return this.state.getState();
+  }
+  /**
+   * Start auto-mode loop
+   */
+  async start(options, runIteration) {
+    if (this.isRunning) {
+      throw new Error("Auto-mode is already running");
+    }
+    if (await this.state.hasActiveSession()) {
+      const existingState = await this.state.load();
+      if (existingState) {
+        console.log(chalk.yellow(`
+\u26A0 Existing auto-mode session found: ${existingState.sessionId}`));
+        console.log(chalk.gray(`  Status: ${existingState.status}, Iteration: ${existingState.currentIteration}`));
+        console.log(chalk.gray(`  Use /automode resume to continue or /automode cancel to start fresh
+`));
+        return;
+      }
+    }
+    this.isRunning = true;
+    this.isPaused = false;
+    this.abortController = new AbortController();
+    this.startTime = Date.now();
+    this.totalCost = 0;
+    this.gitCommits = [];
+    const maxIterations = options.maxIterations ?? this.settings.maxIterations;
+    const completionPromise = options.completionPromise ?? this.settings.completionPromise;
+    const useWorktree = options.useWorktree ?? this.settings.useWorktree;
+    const checkpointInterval = options.checkpointInterval ?? this.settings.checkpointInterval;
+    const maxRuntime = options.maxRuntime ?? this.settings.maxRuntime;
+    const maxCost = options.maxCost ?? this.settings.maxCost;
+    const sessionId = `automode-${Date.now()}-${crypto.randomBytes(4).toString("hex")}`;
+    console.log(chalk.cyan("\n\u{1F504} Starting Auto-Mode"));
+    console.log(chalk.gray(`   Session: ${sessionId}`));
+    console.log(chalk.gray(`   Max iterations: ${maxIterations}`));
+    console.log(chalk.gray(`   Completion promise: "${completionPromise}"`));
+    console.log(chalk.gray(`   Worktree isolation: ${useWorktree ? "enabled" : "disabled"}`));
+    if (useWorktree) {
+      try {
+        await this.setupWorktree(sessionId);
+        console.log(chalk.gray(`   Branch: ${this.branchName}`));
+      } catch (error) {
+        console.log(chalk.yellow(`   \u26A0 Worktree setup failed, continuing in current branch`));
+        console.log(chalk.gray(`   ${error}`));
+      }
+    }
+    await this.state.initialize({
+      sessionId,
+      prompt: options.prompt,
+      maxIterations,
+      completionPromise,
+      branch: this.branchName ?? void 0,
+      worktreePath: this.worktreePath ?? void 0
+    });
+    console.log(chalk.cyan("\n   Press ESC to cancel auto-mode\n"));
+    await this.session?.append({
+      role: "user",
+      content: `[Auto-Mode Start] ${options.prompt}`,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      _meta: {
+        automode: true,
+        sessionId,
+        maxIterations,
+        completionPromise
+      }
+    });
+    await this.emitHookEvent("automode:start", {
+      sessionId,
+      prompt: options.prompt,
+      maxIterations
+    });
+    try {
+      for (let iteration = 1; iteration <= maxIterations; iteration++) {
+        if (this.abortController.signal.aborted) {
+          break;
+        }
+        while (this.isPaused && !this.abortController.signal.aborted) {
+          await this.delay(500);
+        }
+        const elapsedMinutes = (Date.now() - this.startTime) / 6e4;
+        if (elapsedMinutes >= maxRuntime) {
+          await this.cancel("max_runtime");
+          break;
+        }
+        if (this.totalCost >= maxCost) {
+          await this.cancel("max_cost");
+          break;
+        }
+        console.log(chalk.cyan(`
+\u{1F4CD} Iteration ${iteration}/${maxIterations}`));
+        const result = await runIteration(
+          iteration,
+          options.prompt,
+          this.abortController.signal
+        );
+        if (result.cost) {
+          this.totalCost += result.cost;
+        }
+        await this.session?.append({
+          role: "assistant",
+          content: result.output || `[Iteration ${iteration}] Actions: ${result.actions.join(", ")}`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          _meta: {
+            automode: true,
+            iteration,
+            actions: result.actions,
+            filesCreated: result.filesCreated,
+            filesModified: result.filesModified,
+            tokensUsed: result.tokensUsed,
+            cost: result.cost,
+            error: result.error
+          }
+        });
+        const iterationLog = {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          actions: result.actions,
+          tokensUsed: result.tokensUsed,
+          cost: result.cost
+        };
+        if (result.filesCreated || result.filesModified) {
+          await this.state.updateFileCounts(
+            result.filesCreated ?? 0,
+            result.filesModified ?? 0
+          );
+        }
+        await this.emitHookEvent("automode:iteration", {
+          sessionId,
+          iteration,
+          actions: result.actions,
+          tokensUsed: result.tokensUsed
+        });
+        const hasChanges = (result.filesCreated ?? 0) + (result.filesModified ?? 0) > 0;
+        const errorHash = result.error ? hashError(result.error) : null;
+        const isTestOnly = result.actions.every(
+          (a) => a.toLowerCase().includes("test") || a.toLowerCase().includes("spec")
+        );
+        const circuitResult = this.state.checkCircuitBreaker(
+          hasChanges,
+          errorHash,
+          isTestOnly,
+          {
+            noProgress: this.settings.noProgressThreshold,
+            sameError: this.settings.sameErrorThreshold,
+            testOnly: this.settings.testOnlyThreshold
+          }
+        );
+        if (circuitResult.triggered) {
+          console.log(chalk.yellow(`
+\u26A1 Circuit breaker triggered: ${circuitResult.reason}`));
+          await this.cancel("circuit_breaker");
+          break;
+        }
+        if (result.output && this.state.checkCompletionPromise(result.output)) {
+          console.log(chalk.green(`
+\u2705 Completion promise detected!`));
+          await this.complete();
+          break;
+        }
+        if (iteration % checkpointInterval === 0) {
+          await this.createCheckpoint(iteration);
+        }
+        await this.state.recordIteration(iterationLog);
+      }
+      const currentState = this.state.getState();
+      if (currentState && currentState.status === "running") {
+        if (currentState.currentIteration >= maxIterations) {
+          console.log(chalk.yellow(`
+\u26A0 Maximum iterations (${maxIterations}) reached`));
+          await this.cancel("max_iterations");
+        }
+      }
+    } catch (error) {
+      console.error(chalk.red(`
+\u274C Auto-mode error: ${error}`));
+      await this.state.setStatus("failed", "error", String(error));
+      await this.emitHookEvent("automode:error", {
+        sessionId,
+        error: String(error)
+      });
+    } finally {
+      await this.cleanup();
+    }
+  }
+  /**
+   * Cancel the auto-mode loop
+   */
+  async cancel(reason = "user_cancel") {
+    if (!this.isRunning) return;
+    console.log(chalk.yellow(`
+\u26A0 Auto-mode cancelled: ${reason}`));
+    this.abortController?.abort();
+    await this.state.setStatus("cancelled", reason);
+    const currentState = this.state.getState();
+    if (currentState) {
+      await this.session?.append({
+        role: "assistant",
+        content: `[Auto-Mode Cancelled] Reason: ${reason}. Stopped at iteration ${currentState.currentIteration}. Files created: ${currentState.filesCreated}, Files modified: ${currentState.filesModified}`,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        _meta: {
+          automode: true,
+          status: "cancelled",
+          reason,
+          iterations: currentState.currentIteration,
+          filesCreated: currentState.filesCreated,
+          filesModified: currentState.filesModified,
+          totalCost: this.totalCost
+        }
+      });
+      await this.emitHookEvent("automode:cancel", {
+        sessionId: currentState.sessionId,
+        reason,
+        iteration: currentState.currentIteration
+      });
+    }
+  }
+  /**
+   * Pause the auto-mode loop
+   */
+  async pause() {
+    if (!this.isRunning || this.isPaused) return;
+    this.isPaused = true;
+    await this.state.setStatus("paused");
+    const currentState = this.state.getState();
+    if (currentState) {
+      console.log(chalk.yellow(`
+\u23F8\uFE0F Auto-mode paused at iteration ${currentState.currentIteration}`));
+      await this.emitHookEvent("automode:pause", {
+        sessionId: currentState.sessionId,
+        iteration: currentState.currentIteration
+      });
+    }
+  }
+  /**
+   * Resume the auto-mode loop
+   */
+  async resume() {
+    if (!this.isRunning || !this.isPaused) return;
+    this.isPaused = false;
+    await this.state.setStatus("running");
+    const currentState = this.state.getState();
+    if (currentState) {
+      console.log(chalk.cyan(`
+\u25B6\uFE0F Auto-mode resumed at iteration ${currentState.currentIteration}`));
+      await this.emitHookEvent("automode:resume", {
+        sessionId: currentState.sessionId,
+        iteration: currentState.currentIteration
+      });
+    }
+  }
+  /**
+   * Mark auto-mode as complete
+   */
+  async complete() {
+    await this.state.setStatus("completed", "completion");
+    const currentState = this.state.getState();
+    if (currentState) {
+      try {
+        this.detectedPatterns = await this.patternDetector.detect();
+        await this.storeDetectedPatterns();
+        console.log(chalk.gray(`   \u{1F50D} Detected patterns saved to memory`));
+        await this.agentsMdUpdater.update({ patterns: this.detectedPatterns });
+        console.log(chalk.gray(`   \u{1F4DD} AGENTS.md updated with project info`));
+      } catch (error) {
+        console.log(chalk.gray(`   \u26A0 Pattern detection failed: ${error}`));
+      }
+      await this.session?.append({
+        role: "assistant",
+        content: `[Auto-Mode Complete] Task completed successfully after ${currentState.currentIteration} iterations. Files created: ${currentState.filesCreated}, Files modified: ${currentState.filesModified}`,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        _meta: {
+          automode: true,
+          status: "completed",
+          iterations: currentState.currentIteration,
+          filesCreated: currentState.filesCreated,
+          filesModified: currentState.filesModified,
+          totalCost: this.totalCost,
+          detectedPatterns: this.detectedPatterns
+        }
+      });
+      await this.emitHookEvent("automode:complete", {
+        sessionId: currentState.sessionId,
+        iterations: currentState.currentIteration,
+        filesCreated: currentState.filesCreated,
+        filesModified: currentState.filesModified
+      });
+      if (this.worktreePath && this.branchName && this.originalBranch) {
+        await this.mergeWorktree();
+      }
+    }
+  }
+  /**
+   * Store detected patterns in project memory
+   */
+  async storeDetectedPatterns() {
+    if (!this.memoryManager || !this.detectedPatterns) return;
+    const patterns = this.detectedPatterns;
+    if (patterns.techStack.length > 0) {
+      await this.memoryManager.store(
+        `Tech Stack: ${patterns.techStack.join(", ")}`,
+        "project",
+        ["auto-detected", "tech-stack"],
+        "automode"
+      );
+    }
+    if (patterns.framework) {
+      await this.memoryManager.store(
+        `Framework: ${patterns.framework}`,
+        "project",
+        ["auto-detected", "framework"],
+        "automode"
+      );
+    }
+    if (patterns.packageManager) {
+      await this.memoryManager.store(
+        `Package Manager: ${patterns.packageManager}`,
+        "project",
+        ["auto-detected", "package-manager"],
+        "automode"
+      );
+    }
+    if (patterns.testCommand) {
+      await this.memoryManager.store(
+        `Test Command: ${patterns.testCommand}`,
+        "project",
+        ["auto-detected", "command", "test"],
+        "automode"
+      );
+    }
+    if (patterns.buildCommand) {
+      await this.memoryManager.store(
+        `Build Command: ${patterns.buildCommand}`,
+        "project",
+        ["auto-detected", "command", "build"],
+        "automode"
+      );
+    }
+    if (patterns.lintCommand) {
+      await this.memoryManager.store(
+        `Lint Command: ${patterns.lintCommand}`,
+        "project",
+        ["auto-detected", "command", "lint"],
+        "automode"
+      );
+    }
+  }
+  /**
+   * Set up git worktree for isolation
+   */
+  async setupWorktree(sessionId) {
+    try {
+      this.originalBranch = execSync("git rev-parse --abbrev-ref HEAD", {
+        cwd: this.workspaceRoot,
+        encoding: "utf-8"
+      }).trim();
+    } catch {
+      throw new Error("Not a git repository");
+    }
+    this.branchName = `autohand-automode-${Date.now()}`;
+    const tempDir = path5.join("/tmp", `autohand-worktree-${crypto.randomBytes(4).toString("hex")}`);
+    this.worktreePath = tempDir;
+    try {
+      execSync(`git worktree add -b ${this.branchName} ${tempDir}`, {
+        cwd: this.workspaceRoot,
+        encoding: "utf-8"
+      });
+    } catch (error) {
+      this.worktreePath = null;
+      this.branchName = null;
+      throw error;
+    }
+  }
+  /**
+   * Create a checkpoint (git commit)
+   */
+  async createCheckpoint(iteration) {
+    const workDir = this.worktreePath ?? this.workspaceRoot;
+    try {
+      const status = execSync("git status --porcelain", {
+        cwd: workDir,
+        encoding: "utf-8"
+      }).trim();
+      if (!status) {
+        return;
+      }
+      execSync("git add -A", { cwd: workDir, encoding: "utf-8" });
+      const message = `automode: checkpoint at iteration ${iteration}`;
+      execSync(`git commit -m "${message}"`, { cwd: workDir, encoding: "utf-8" });
+      const hash = execSync("git rev-parse --short HEAD", {
+        cwd: workDir,
+        encoding: "utf-8"
+      }).trim();
+      await this.state.recordCheckpoint(hash, message);
+      this.gitCommits.push({ hash, message });
+      console.log(chalk.gray(`   \u{1F4CC} Checkpoint: ${hash}`));
+      const currentState = this.state.getState();
+      if (currentState) {
+        await this.emitHookEvent("automode:checkpoint", {
+          sessionId: currentState.sessionId,
+          iteration,
+          commit: hash
+        });
+      }
+    } catch (error) {
+      console.log(chalk.gray(`   \u26A0 Checkpoint failed: ${error}`));
+    }
+  }
+  /**
+   * Merge worktree back to original branch
+   */
+  async mergeWorktree() {
+    if (!this.worktreePath || !this.branchName || !this.originalBranch) {
+      return;
+    }
+    try {
+      console.log(chalk.cyan(`
+\u{1F500} Merging ${this.branchName} to ${this.originalBranch}...`));
+      execSync(`git checkout ${this.originalBranch}`, {
+        cwd: this.workspaceRoot,
+        encoding: "utf-8"
+      });
+      execSync(`git merge ${this.branchName} --no-edit`, {
+        cwd: this.workspaceRoot,
+        encoding: "utf-8"
+      });
+      console.log(chalk.green(`   \u2705 Successfully merged to ${this.originalBranch}`));
+      await this.cleanupWorktree();
+    } catch (error) {
+      console.log(chalk.yellow(`   \u26A0 Merge failed: ${error}`));
+      console.log(chalk.gray(`   Worktree preserved at: ${this.worktreePath}`));
+    }
+  }
+  /**
+   * Clean up worktree
+   */
+  async cleanupWorktree() {
+    if (!this.worktreePath || !this.branchName) return;
+    try {
+      execSync(`git worktree remove ${this.worktreePath} --force`, {
+        cwd: this.workspaceRoot,
+        encoding: "utf-8"
+      });
+      execSync(`git branch -d ${this.branchName}`, {
+        cwd: this.workspaceRoot,
+        encoding: "utf-8"
+      });
+    } catch {
+    }
+  }
+  /**
+   * Clean up after auto-mode ends
+   */
+  async cleanup() {
+    this.isRunning = false;
+    this.isPaused = false;
+    this.abortController = null;
+    const currentState = this.state.getState();
+    if (currentState) {
+      try {
+        const changelogPath = await generateChangelog(
+          this.workspaceRoot,
+          currentState,
+          this.state.getIterations(),
+          this.gitCommits
+        );
+        console.log(chalk.gray(`
+\u{1F4DD} Changelog saved: ${changelogPath}`));
+      } catch (error) {
+        console.log(chalk.gray(`   \u26A0 Changelog generation failed: ${error}`));
+      }
+    }
+    this.printSummary();
+  }
+  /**
+   * Print session summary
+   */
+  printSummary() {
+    const state = this.state.getState();
+    if (!state) return;
+    const durationMs = Date.now() - this.startTime;
+    const durationMinutes = Math.round(durationMs / 6e4);
+    console.log(chalk.cyan("\n\u{1F4CA} Auto-Mode Summary"));
+    console.log(chalk.gray(`   Status: ${state.status}`));
+    console.log(chalk.gray(`   Iterations: ${state.currentIteration}`));
+    console.log(chalk.gray(`   Duration: ${durationMinutes} minutes`));
+    console.log(chalk.gray(`   Files created: ${state.filesCreated}`));
+    console.log(chalk.gray(`   Files modified: ${state.filesModified}`));
+    if (this.totalCost > 0) {
+      console.log(chalk.gray(`   Estimated cost: $${this.totalCost.toFixed(2)}`));
+    }
+    if (state.branch) {
+      console.log(chalk.gray(`   Branch: ${state.branch}`));
+    }
+    console.log("");
+  }
+  /**
+   * Emit a hook event
+   */
+  async emitHookEvent(event, context) {
+    this.emit(event, context);
+    if (this.hookManager) {
+      try {
+        await this.hookManager.executeHooks(event, context);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Delay helper
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+function getAutomodeOptions(cliOptions, config) {
+  if (!cliOptions.autoMode) {
+    return null;
+  }
+  const configSettings = config.automode ?? {};
+  return {
+    prompt: cliOptions.autoMode,
+    maxIterations: cliOptions.maxIterations ?? configSettings.maxIterations ?? DEFAULTS.maxIterations,
+    completionPromise: cliOptions.completionPromise ?? configSettings.completionPromise ?? DEFAULTS.completionPromise,
+    useWorktree: cliOptions.noWorktree === true ? false : configSettings.useWorktree ?? DEFAULTS.useWorktree,
+    checkpointInterval: cliOptions.checkpointInterval ?? configSettings.checkpointInterval ?? DEFAULTS.checkpointInterval,
+    maxRuntime: cliOptions.maxRuntime ?? configSettings.maxRuntime ?? DEFAULTS.maxRuntime,
+    maxCost: cliOptions.maxCost ?? configSettings.maxCost ?? DEFAULTS.maxCost,
+    dryRun: cliOptions.dryRun
+  };
+}
+export {
+  AutomodeManager,
+  getAutomodeOptions
+};
+/**
+ * Auto-Mode State Management
+ *
+ * Handles reading/writing the .autohand/automode.local.md state file
+ * that tracks auto-mode session progress.
+ *
+ * @license Apache-2.0
+ */
+/**
+ * Auto-Mode Changelog Generation
+ *
+ * Generates AUTOMODE_CHANGELOG.md after auto-mode session completes.
+ *
+ * @license Apache-2.0
+ */
+/**
+ * Pattern Detector
+ *
+ * Automatically detects project patterns like tech stack, test/build/lint commands,
+ * and frameworks from project configuration files.
+ *
+ * @license Apache-2.0
+ */
+/**
+ * AGENTS.md Updater
+ *
+ * Automatically updates AGENTS.md with discovered project patterns,
+ * tech stack, commands, and skills used during auto-mode sessions.
+ *
+ * @license Apache-2.0
+ */
+/**
+ * Auto-Mode Manager
+ *
+ * Orchestrates the autonomous loop feature inspired by the Ralph technique.
+ * Manages iteration cycles, git worktree isolation, checkpointing, and
+ * cancellation via ESC, hooks, RPC, and ACP.
+ *
+ * @license Apache-2.0
+ */