autohand-cli 0.8.2 → 0.9.0

package/dist/chunk-LN7D3EJZ.js

@@ -0,0 +1,387 @@
+import {
+  resolveRipgrepCommand
+} from "./chunk-UOQECODR.js";
+
+// src/startup/checks.ts
+import { spawn } from "child_process";
+import { constants as fsConstants } from "fs";
+import os from "os";
+import chalk from "chalk";
+import fs from "fs-extra";
+var GIT_COMMAND_TIMEOUT_MS = 5e3;
+var toolCheckResultsPromise;
+function getCurrentBunVersion() {
+  return process.versions.bun;
+}
+var REQUIRED_TOOLS = [
+  {
+    name: "git",
+    command: "git",
+    versionFlag: "--version",
+    required: true,
+    description: "Version control (required for file tracking, undo, and git operations)",
+    installHints: {
+      darwin: "brew install git",
+      linux: "sudo apt install git  # or: sudo dnf install git",
+      win32: "winget install Git.Git  # or download from https://git-scm.com"
+    }
+  },
+  {
+    name: "ripgrep",
+    command: "rg",
+    versionFlag: "--version",
+    required: false,
+    description: "Fast code search (recommended for better search performance)",
+    installHints: {
+      darwin: "brew install ripgrep",
+      linux: "sudo apt install ripgrep  # or: cargo install ripgrep",
+      win32: "winget install BurntSushi.ripgrep  # or: scoop install ripgrep"
+    }
+  }
+];
+var OPTIONAL_TOOLS = [
+  {
+    name: "node",
+    command: "node",
+    versionFlag: "--version",
+    required: false,
+    description: "Node.js runtime (for npm/yarn package management)",
+    installHints: {
+      darwin: "brew install node  # or: nvm install node",
+      linux: "sudo apt install nodejs  # or: nvm install node",
+      win32: "winget install OpenJS.NodeJS  # or download from https://nodejs.org"
+    },
+    minVersion: "18.0.0"
+  },
+  {
+    name: "bun",
+    command: "bun",
+    versionFlag: "--version",
+    required: false,
+    description: "Bun runtime (fast JavaScript/TypeScript runtime)",
+    installHints: {
+      darwin: "curl -fsSL https://bun.sh/install | bash",
+      linux: "curl -fsSL https://bun.sh/install | bash",
+      win32: 'powershell -c "irm bun.sh/install.ps1 | iex"'
+    }
+  }
+];
+function checkTool(tool) {
+  const platform = os.platform();
+  const installHint = tool.installHints[platform] || tool.installHints.linux;
+  const command = tool.command === "rg" ? resolveRipgrepCommand() : tool.command;
+  const currentBunVersion = tool.command === "bun" ? getCurrentBunVersion() : void 0;
+  if (tool.command === "bun") {
+    return Promise.resolve({
+      name: tool.name,
+      installed: currentBunVersion !== void 0,
+      version: currentBunVersion,
+      required: tool.required,
+      description: tool.description,
+      installHint: currentBunVersion === void 0 ? installHint : void 0
+    });
+  }
+  return new Promise((resolve) => {
+    try {
+      const proc = spawn(command, [tool.versionFlag], {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      const timeout = setTimeout(() => {
+        proc.kill();
+        resolve({
+          name: tool.name,
+          installed: false,
+          required: tool.required,
+          description: tool.description,
+          installHint
+        });
+      }, 5e3);
+      proc.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      proc.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      proc.on("close", (code) => {
+        clearTimeout(timeout);
+        if (code === 0) {
+          const output = (stdout || stderr).trim();
+          const versionMatch = output.match(/(\d+\.\d+(\.\d+)?)/);
+          const version = versionMatch ? versionMatch[1] : "unknown";
+          resolve({
+            name: tool.name,
+            installed: true,
+            version,
+            required: tool.required,
+            description: tool.description
+          });
+        } else {
+          resolve({
+            name: tool.name,
+            installed: false,
+            required: tool.required,
+            description: tool.description,
+            installHint
+          });
+        }
+      });
+      proc.on("error", () => {
+        clearTimeout(timeout);
+        resolve({
+          name: tool.name,
+          installed: false,
+          required: tool.required,
+          description: tool.description,
+          installHint
+        });
+      });
+    } catch {
+      resolve({
+        name: tool.name,
+        installed: false,
+        required: tool.required,
+        description: tool.description,
+        installHint
+      });
+    }
+  });
+}
+function checkStartupTools() {
+  toolCheckResultsPromise ??= Promise.all(
+    [...REQUIRED_TOOLS, ...OPTIONAL_TOOLS].map((tool) => checkTool(tool))
+  );
+  return toolCheckResultsPromise;
+}
+async function checkWorkspaceWritable(workspaceRoot) {
+  try {
+    const testFile = `${workspaceRoot}/.autohand-write-test-${Date.now()}`;
+    await fs.writeFile(testFile, "test");
+    await fs.remove(testFile);
+    return { writable: true };
+  } catch (error) {
+    return {
+      writable: false,
+      error: `Cannot write to workspace: ${error.message}`
+    };
+  }
+}
+async function validateWorkspacePath(workspaceRoot) {
+  try {
+    if (!await fs.pathExists(workspaceRoot)) {
+      return {
+        valid: false,
+        error: `Workspace path does not exist: ${workspaceRoot}`
+      };
+    }
+    const stats = await fs.stat(workspaceRoot);
+    if (!stats.isDirectory()) {
+      return {
+        valid: false,
+        error: `Workspace path is not a directory: ${workspaceRoot}`
+      };
+    }
+    await fs.access(workspaceRoot, fsConstants.R_OK | fsConstants.W_OK);
+    return { valid: true };
+  } catch (error) {
+    return {
+      valid: false,
+      error: `Cannot access workspace: ${error.message}`
+    };
+  }
+}
+function isEmptyDirectory(dir) {
+  try {
+    const entries = fs.readdirSync(dir);
+    const significantEntries = entries.filter((e) => !e.startsWith(".") || e === ".git");
+    return significantEntries.length === 0;
+  } catch {
+    return false;
+  }
+}
+function runGitCommand(args, cwd) {
+  return new Promise((resolve) => {
+    try {
+      const proc = spawn("git", args, { cwd, stdio: ["pipe", "pipe", "pipe"] });
+      let stdout = "";
+      const timeout = setTimeout(() => {
+        proc.kill();
+        resolve(void 0);
+      }, GIT_COMMAND_TIMEOUT_MS);
+      proc.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      proc.on("close", (code) => {
+        clearTimeout(timeout);
+        resolve(code === 0 ? stdout.trim() : void 0);
+      });
+      proc.on("error", () => {
+        clearTimeout(timeout);
+        resolve(void 0);
+      });
+    } catch {
+      resolve(void 0);
+    }
+  });
+}
+async function getGitBranch(workspaceRoot) {
+  const headBranch = readGitHeadBranch(workspaceRoot);
+  if (headBranch) return headBranch;
+  const branch = await runGitCommand(["rev-parse", "--abbrev-ref", "HEAD"], workspaceRoot);
+  if (branch) return branch;
+  return runGitCommand(["symbolic-ref", "--short", "HEAD"], workspaceRoot);
+}
+function readGitHeadBranch(workspaceRoot) {
+  try {
+    const head = fs.readFileSync(`${workspaceRoot}/.git/HEAD`, "utf8").trim();
+    const refPrefix = "ref: refs/heads/";
+    if (head.startsWith(refPrefix)) {
+      const branch = head.slice(refPrefix.length).trim();
+      return branch || void 0;
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+async function checkGitRepo(workspaceRoot) {
+  const gitDirExists = fs.existsSync(`${workspaceRoot}/.git`);
+  if (gitDirExists) {
+    if (!fs.existsSync(`${workspaceRoot}/.git/HEAD`)) {
+      return { isGitRepo: true };
+    }
+    const branch = await getGitBranch(workspaceRoot);
+    return {
+      isGitRepo: true,
+      branch
+    };
+  }
+  if (isEmptyDirectory(workspaceRoot)) {
+    const initResult = await runGitCommand(["init"], workspaceRoot);
+    if (initResult !== void 0 || fs.existsSync(`${workspaceRoot}/.git/HEAD`)) {
+      if (os.platform() === "darwin") {
+        try {
+          const gitignorePath = `${workspaceRoot}/.gitignore`;
+          if (!fs.existsSync(gitignorePath)) {
+            fs.writeFileSync(gitignorePath, ".DS_Store\n");
+          }
+        } catch {
+        }
+      }
+      const branch = await getGitBranch(workspaceRoot) || "main";
+      return {
+        isGitRepo: true,
+        branch,
+        initialized: true
+      };
+    }
+  }
+  return { isGitRepo: false };
+}
+function getPackageManagerHint() {
+  const platform = os.platform();
+  switch (platform) {
+    case "darwin":
+      return "Homebrew (brew)";
+    case "linux":
+      return "apt, dnf, or your distro package manager";
+    case "win32":
+      return "winget, scoop, or chocolatey";
+    default:
+      return "your system package manager";
+  }
+}
+async function runStartupChecks(workspaceRoot) {
+  const warnings = [];
+  const [toolResults, workspaceCheck, gitCheck] = await Promise.all([
+    checkStartupTools(),
+    checkWorkspaceWritable(workspaceRoot),
+    checkGitRepo(workspaceRoot)
+  ]);
+  for (const result of toolResults) {
+    if (!result.installed && result.required) {
+      warnings.push(`Required tool '${result.name}' is not installed`);
+    }
+  }
+  if (!workspaceCheck.writable) {
+    warnings.push(workspaceCheck.error || "Workspace is not writable");
+  }
+  const allRequiredMet = toolResults.filter((r) => r.required).every((r) => r.installed);
+  return {
+    tools: toolResults,
+    workspace: {
+      path: workspaceRoot,
+      writable: workspaceCheck.writable,
+      isGitRepo: gitCheck.isGitRepo,
+      branch: gitCheck.branch,
+      initialized: gitCheck.initialized,
+      error: workspaceCheck.error
+    },
+    allRequiredMet,
+    warnings
+  };
+}
+function printStartupCheckResults(results, verbose = false) {
+  const missingRequired = results.tools.filter((t) => t.required && !t.installed);
+  const missingOptional = results.tools.filter((t) => !t.required && !t.installed);
+  if (results.workspace.initialized) {
+    console.log(chalk.green("\u2713 Initialized git repository"));
+    console.log();
+  }
+  if (missingRequired.length === 0 && !verbose) {
+    return;
+  }
+  console.log();
+  if (missingRequired.length > 0) {
+    console.log(chalk.red.bold("\u26A0 Missing required tools:"));
+    console.log();
+    for (const tool of missingRequired) {
+      console.log(chalk.red(`  \u2717 ${tool.name}`));
+      console.log(chalk.gray(`    ${tool.description}`));
+      console.log(chalk.cyan(`    Install: ${tool.installHint}`));
+      console.log();
+    }
+  }
+  if (missingOptional.length > 0 && verbose) {
+    console.log(chalk.yellow("Optional tools not installed:"));
+    for (const tool of missingOptional) {
+      console.log(chalk.yellow(`  \u25CB ${tool.name}`) + chalk.gray(` - ${tool.description}`));
+      console.log(chalk.gray(`    Install: ${tool.installHint}`));
+    }
+    console.log();
+  }
+  if (!results.workspace.writable) {
+    console.log(chalk.red(`\u26A0 Workspace issue: ${results.workspace.error}`));
+    console.log();
+  }
+  if (verbose) {
+    const installed = results.tools.filter((t) => t.installed);
+    if (installed.length > 0) {
+      console.log(chalk.green("Installed tools:"));
+      for (const tool of installed) {
+        const version = tool.version ? chalk.gray(` (${tool.version})`) : "";
+        console.log(chalk.green(`  \u2713 ${tool.name}${version}`));
+      }
+      console.log();
+    }
+  }
+  if (!results.allRequiredMet) {
+    console.log(chalk.red.bold("Some required tools are missing. Autohand may not work correctly."));
+    console.log(chalk.gray(`Use ${getPackageManagerHint()} to install them.`));
+    console.log();
+  }
+}
+
+export {
+  validateWorkspacePath,
+  runStartupChecks,
+  printStartupCheckResults
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Startup checks - validates required tools and environment
+ */

package/dist/{chunk-643VRA5S.cjs → chunk-LQBONA55.cjs}

@@ -1,15 +1,22 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/core/HookManager.ts
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// src/core/HookManager.ts
 var _child_process = require('child_process');
 var _minimatch = require('minimatch');
 var DEFAULT_HOOK_TIMEOUT = 5e3;
-var HookManager = class {
-  constructor(options) {
-    this.initialized = false;
+var HookManager = (_class = class {
+  
+  
+  
+  
+  __init() {this.initialized = false}
+  constructor(options) {;_class.prototype.__init.call(this);
     this.settings = _nullishCoalesce(options.settings, () => ( { enabled: true, hooks: [] }));
     this.workspaceRoot = options.workspaceRoot;
     this.onPersist = options.onPersist;
     this.onHookOutput = options.onHookOutput;
   }
+  setWorkspaceRoot(workspaceRoot) {
+    this.workspaceRoot = workspaceRoot;
+  }
   /**
    * Initialize hooks - set up default hooks if none exist
    */
@@ -28,7 +35,7 @@ var HookManager = class {
    */
   async installDefaultHooks() {
     try {
-      const { DEFAULT_HOOKS, SMART_COMMIT_HOOK } = await Promise.resolve().then(() => _interopRequireWildcard(require("./defaultHooks-RCXPHF4M.cjs")));
+      const { DEFAULT_HOOKS, SMART_COMMIT_HOOK } = await Promise.resolve().then(() => _interopRequireWildcard(require("./defaultHooks-2V2CQL63.cjs")));
       this.settings.hooks = [...DEFAULT_HOOKS, SMART_COMMIT_HOOK];
       if (this.onPersist) {
         await this.onPersist();
@@ -56,7 +63,7 @@ var HookManager = class {
    */
   async mergeDefaultHooks() {
     try {
-      const { DEFAULT_HOOKS, SMART_COMMIT_HOOK } = await Promise.resolve().then(() => _interopRequireWildcard(require("./defaultHooks-RCXPHF4M.cjs")));
+      const { DEFAULT_HOOKS, SMART_COMMIT_HOOK } = await Promise.resolve().then(() => _interopRequireWildcard(require("./defaultHooks-2V2CQL63.cjs")));
       const allDefaults = [...DEFAULT_HOOKS, SMART_COMMIT_HOOK];
       const existingHooks = _nullishCoalesce(this.settings.hooks, () => ( []));
       const existingIds = new Set(existingHooks.map((h) => this.getHookIdentifier(h)));
@@ -84,7 +91,7 @@ var HookManager = class {
       const hooksDir = path.join(os.homedir(), ".autohand", "hooks");
       const isWindows = os.platform() === "win32";
       await fs.ensureDir(hooksDir);
-      const { HOOK_SCRIPTS, HOOK_SCRIPTS_WINDOWS } = await Promise.resolve().then(() => _interopRequireWildcard(require("./defaultHooks-RCXPHF4M.cjs")));
+      const { HOOK_SCRIPTS, HOOK_SCRIPTS_WINDOWS } = await Promise.resolve().then(() => _interopRequireWildcard(require("./defaultHooks-2V2CQL63.cjs")));
       for (const [scriptName, scriptContent] of Object.entries(HOOK_SCRIPTS)) {
         const scriptPath = path.join(hooksDir, scriptName);
         if (!await fs.pathExists(scriptPath)) {
@@ -274,6 +281,12 @@ var HookManager = class {
     if (context.automodeCancelReason) env.HOOK_AUTOMODE_CANCEL_REASON = context.automodeCancelReason;
     if (context.automodeCheckpointCommit) env.HOOK_AUTOMODE_CHECKPOINT = context.automodeCheckpointCommit;
     if (context.automodeTotalCost !== void 0) env.HOOK_AUTOMODE_COST = String(context.automodeTotalCost);
+    if (context.event.startsWith("review:")) {
+      if (context.reviewPath) env.HOOK_REVIEW_PATH = context.reviewPath;
+      if (context.reviewScope) env.HOOK_REVIEW_SCOPE = context.reviewScope;
+      if (context.reviewError) env.HOOK_REVIEW_ERROR = context.reviewError;
+      if (context.reviewInstructions) env.HOOK_REVIEW_INSTRUCTIONS = context.reviewInstructions;
+    }
     if (context.additionalWorkspaces && context.additionalWorkspaces.length > 0) {
       env.HOOK_ADDITIONAL_WORKSPACES = JSON.stringify(context.additionalWorkspaces);
     }
@@ -334,6 +347,11 @@ var HookManager = class {
       automode_cancel_reason: context.automodeCancelReason,
       automode_checkpoint_commit: context.automodeCheckpointCommit,
       automode_total_cost: context.automodeTotalCost,
+      // Review context
+      review_path: context.reviewPath,
+      review_scope: context.reviewScope,
+      review_instructions: context.reviewInstructions,
+      review_error: context.reviewError,
       // Multi-directory support
       additional_workspaces: context.additionalWorkspaces
     });
@@ -524,6 +542,12 @@ var HookManager = class {
       "automode:cancel",
       "automode:complete",
       "automode:error",
+      // Review events
+      "review:start",
+      "review:end",
+      "review:paused",
+      "review:failed",
+      "review:completed",
       // Team events
       "team-created",
       "teammate-spawned",
@@ -542,7 +566,7 @@ var HookManager = class {
     }
     return summary;
   }
-};
+}, _class);
 
 
 

package/dist/{chunk-NCC6ETZS.js → chunk-LUMV3DB2.js}

@@ -6,6 +6,8 @@ import { EventEmitter } from "events";
 var READ_ONLY_TOOLS = [
   // File reading
   "read_file",
+  "fff_grep",
+  "fff_find",
   "search",
   "search_with_context",
   "semantic_search",
@@ -30,10 +32,13 @@ var READ_ONLY_TOOLS = [
   "recall_memory",
   // Meta
   "tools_registry",
+  "tool_search",
   "plan",
+  "exit_plan_mode",
   "ask_followup_question"
 ];
 var PlanModeManager = class extends EventEmitter {
+  state;
   constructor() {
     super();
     this.state = {
@@ -224,48 +229,50 @@ function getPlanModeManager() {
   }
   return planModeManager;
 }
-async function plan(_ctx, args) {
+function formatPlanModeToggleMessage(enabled) {
+  if (enabled) {
+    return `${chalk.cyan("[PLAN]")} ${chalk.cyan("Plan mode active - tools are read-only")}`;
+  }
+  return `${chalk.gray("Plan mode")} ${chalk.red("OFF")}`;
+}
+async function plan(_ctx, args, opts) {
   const manager = getPlanModeManager();
   const subcommand = args?.trim().toLowerCase();
+  const out = opts?.output ?? console.log;
   switch (subcommand) {
     case "on":
     case "enable":
       if (manager.isEnabled()) {
-        console.log(chalk.yellow("Plan mode is already enabled."));
+        out(chalk.yellow("Plan mode is already enabled."));
         return null;
       }
       manager.enable();
-      console.log(chalk.green("Plan mode enabled."));
-      console.log(chalk.gray("Tools are now read-only. Use /plan off to disable."));
-      console.log(chalk.gray("Tip: Press Shift+Tab twice to quickly toggle plan mode."));
+      out(formatPlanModeToggleMessage(true));
       return null;
     case "off":
     case "disable":
       if (!manager.isEnabled()) {
-        console.log(chalk.yellow("Plan mode is not enabled."));
+        out(chalk.yellow("Plan mode is not enabled."));
         return null;
       }
       manager.disable();
-      console.log(chalk.green("Plan mode disabled."));
-      console.log(chalk.gray("Full tool access restored."));
+      out(formatPlanModeToggleMessage(false));
       return null;
     case "status":
-      return showPlanStatus(manager);
+      return showPlanStatus(manager, out);
     case "":
     case void 0:
       if (manager.isEnabled()) {
         manager.disable();
-        console.log(chalk.green("Plan mode disabled."));
-        console.log(chalk.gray("Full tool access restored."));
+        out(formatPlanModeToggleMessage(false));
       } else {
         manager.enable();
-        console.log(chalk.green("Plan mode enabled."));
-        console.log(chalk.gray("Tools are now read-only."));
+        out(formatPlanModeToggleMessage(true));
       }
       return null;
     default:
-      console.log(chalk.yellow(`Unknown subcommand: ${subcommand}`));
-      console.log(chalk.gray(`
+      out(chalk.yellow(`Unknown subcommand: ${subcommand}`));
+      out(chalk.gray(`
 Usage:
   /plan        - Toggle plan mode
   /plan on     - Enable plan mode
@@ -279,39 +286,39 @@ Keyboard shortcut:
       return null;
   }
 }
-function showPlanStatus(manager) {
+function showPlanStatus(manager, out = console.log) {
   const enabled = manager.isEnabled();
   const phase = manager.getPhase();
   const plan2 = manager.getPlan();
   const indicator = manager.getPromptIndicator();
-  console.log("");
-  console.log(chalk.bold.cyan("Plan Mode Status"));
-  console.log(chalk.gray("\u2500".repeat(40)));
-  console.log(`Status:    ${enabled ? chalk.green("ENABLED") : chalk.gray("DISABLED")}`);
-  console.log(`Phase:     ${chalk.cyan(phase)}`);
-  console.log(`Indicator: ${indicator || chalk.gray("(none)")}`);
+  out("");
+  out(chalk.bold.cyan("Plan Mode Status"));
+  out(chalk.gray("\u2500".repeat(40)));
+  out(`Status:    ${enabled ? chalk.green("ENABLED") : chalk.gray("DISABLED")}`);
+  out(`Phase:     ${chalk.cyan(phase)}`);
+  out(`Indicator: ${indicator || chalk.gray("(none)")}`);
   if (plan2) {
     const completed = plan2.steps.filter((s) => s.status === "completed").length;
     const inProgress = plan2.steps.find((s) => s.status === "in_progress");
-    console.log("");
-    console.log(chalk.bold(`Plan: ${plan2.id}`));
-    console.log(`Progress: ${completed}/${plan2.steps.length} steps`);
-    console.log("");
+    out("");
+    out(chalk.bold(`Plan: ${plan2.id}`));
+    out(`Progress: ${completed}/${plan2.steps.length} steps`);
+    out("");
     for (const step of plan2.steps) {
       const icon = getStepIcon(step.status);
       const color = getStepColor(step.status);
-      console.log(color(`  ${icon} ${step.number}. ${step.description}`));
+      out(color(`  ${icon} ${step.number}. ${step.description}`));
     }
     if (inProgress) {
-      console.log("");
-      console.log(chalk.yellow(`Currently working on: Step ${inProgress.number}`));
+      out("");
+      out(chalk.yellow(`Currently working on: Step ${inProgress.number}`));
     }
   } else {
-    console.log("");
-    console.log(chalk.gray("No plan created yet."));
-    console.log(chalk.gray("Ask the agent to create a plan for your task."));
+    out("");
+    out(chalk.gray("No plan created yet."));
+    out(chalk.gray("Ask the agent to create a plan for your task."));
   }
-  console.log("");
+  out("");
   return null;
 }
 function getStepIcon(status) {
@@ -342,6 +349,7 @@ function getStepColor(status) {
 export {
   metadata,
   getPlanModeManager,
+  formatPlanModeToggleMessage,
   plan
 };
 /**