autohand-cli 0.7.7 → 0.7.9

package/dist/chunk-NCC6ETZS.js

@@ -0,0 +1,362 @@
+// src/commands/plan.ts
+import chalk from "chalk";
+
+// src/modes/planMode/PlanModeManager.ts
+import { EventEmitter } from "events";
+var READ_ONLY_TOOLS = [
+  // File reading
+  "read_file",
+  "search",
+  "search_with_context",
+  "semantic_search",
+  "list_tree",
+  "file_stats",
+  "checksum",
+  // Git read operations
+  "git_status",
+  "git_diff",
+  "git_diff_range",
+  "git_log",
+  "git_branch",
+  "git_stash_list",
+  "git_worktree_list",
+  "git_worktree_status_all",
+  // Web/Research
+  "web_search",
+  "fetch_url",
+  "package_info",
+  "web_repo",
+  // Memory
+  "recall_memory",
+  // Meta
+  "tools_registry",
+  "plan",
+  "ask_followup_question"
+];
+var PlanModeManager = class extends EventEmitter {
+  constructor() {
+    super();
+    this.state = {
+      enabled: false,
+      phase: "planning",
+      plan: null,
+      startedAt: 0
+    };
+  }
+  /**
+   * Check if plan mode is enabled
+   */
+  isEnabled() {
+    return this.state.enabled;
+  }
+  /**
+   * Get current phase
+   */
+  getPhase() {
+    return this.state.phase;
+  }
+  /**
+   * Get current plan
+   */
+  getPlan() {
+    return this.state.plan;
+  }
+  /**
+   * Enable plan mode
+   */
+  enable() {
+    if (this.state.enabled) return;
+    this.state.enabled = true;
+    this.state.phase = "planning";
+    this.state.startedAt = Date.now();
+    this.emit("enabled");
+  }
+  /**
+   * Disable plan mode
+   */
+  disable() {
+    if (!this.state.enabled) return;
+    this.state.enabled = false;
+    this.emit("disabled");
+  }
+  /**
+   * Toggle plan mode on/off
+   */
+  toggle() {
+    if (this.state.enabled) {
+      this.disable();
+    } else {
+      this.enable();
+    }
+  }
+  /**
+   * Handle Shift+Tab keypress - simple toggle on/off
+   */
+  handleShiftTab() {
+    this.toggle();
+  }
+  /**
+   * Get prompt indicator based on current state
+   */
+  getPromptIndicator() {
+    if (!this.state.enabled) {
+      return "";
+    }
+    if (this.state.phase === "executing") {
+      return "[EXEC]";
+    }
+    return "[PLAN]";
+  }
+  /**
+   * Get i18n key for status description based on current phase
+   */
+  getStatusDescriptionKey() {
+    if (!this.state.enabled) {
+      return "";
+    }
+    if (this.state.phase === "executing") {
+      return "ui.planModeExecuting";
+    }
+    return "ui.planModeActive";
+  }
+  /**
+   * Set the current plan
+   */
+  setPlan(plan2) {
+    this.state.plan = plan2;
+    this.emit("plan:set", plan2);
+  }
+  /**
+   * Start plan execution
+   * Transitions from planning to executing phase
+   */
+  startExecution() {
+    if (!this.state.plan) {
+      throw new Error("No plan to execute");
+    }
+    this.state.phase = "executing";
+    this.state.executionStartedAt = Date.now();
+    this.emit("execution:started", this.state.plan);
+  }
+  /**
+   * Get list of read-only tools allowed in plan mode
+   */
+  getReadOnlyTools() {
+    return [...READ_ONLY_TOOLS];
+  }
+  /**
+   * Get current state (for persistence/debugging)
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Restore state from persistence
+   */
+  restore(state) {
+    this.state = {
+      ...this.state,
+      ...state
+    };
+    if (this.state.enabled) {
+      this.emit("restored", this.state);
+    }
+  }
+  /**
+   * Accept the plan with specified option
+   * This starts execution with the given configuration
+   *
+   * Options:
+   * - clear_context_auto_accept: Clear context and auto-accept edits (best for plan adherence)
+   * - manual_approve: Manually approve each edit
+   * - auto_accept: Auto-accept edits without clearing context
+   */
+  acceptPlan(option) {
+    if (!this.state.plan) {
+      throw new Error("No plan to accept");
+    }
+    const config = {
+      option,
+      clearContext: option === "clear_context_auto_accept",
+      autoAcceptEdits: option !== "manual_approve"
+    };
+    this.state.phase = "executing";
+    this.state.executionStartedAt = Date.now();
+    this.emit("plan:accepted", config);
+    this.emit("execution:started", this.state.plan);
+    return config;
+  }
+  /**
+   * Get available plan acceptance options for UI display
+   */
+  getAcceptOptions() {
+    return [
+      {
+        id: "clear_context_auto_accept",
+        label: "Yes, clear context and auto-accept edits",
+        description: "Clears context for fresh start, improves plan adherence. Auto-accepts all edits.",
+        shortcut: "shift+tab"
+      },
+      {
+        id: "manual_approve",
+        label: "Yes, and manually approve edits",
+        description: "Keep context, review and approve each edit individually."
+      },
+      {
+        id: "auto_accept",
+        label: "Yes, auto-accept edits",
+        description: "Keep context, auto-accept all edits without review."
+      }
+    ];
+  }
+};
+
+// src/commands/plan.ts
+var metadata = {
+  command: "/plan",
+  description: "toggle plan mode for safe code exploration",
+  implemented: true
+};
+var planModeManager = null;
+function getPlanModeManager() {
+  if (!planModeManager) {
+    planModeManager = new PlanModeManager();
+  }
+  return planModeManager;
+}
+async function plan(_ctx, args) {
+  const manager = getPlanModeManager();
+  const subcommand = args?.trim().toLowerCase();
+  switch (subcommand) {
+    case "on":
+    case "enable":
+      if (manager.isEnabled()) {
+        console.log(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."));
+      return null;
+    case "off":
+    case "disable":
+      if (!manager.isEnabled()) {
+        console.log(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."));
+      return null;
+    case "status":
+      return showPlanStatus(manager);
+    case "":
+    case void 0:
+      if (manager.isEnabled()) {
+        manager.disable();
+        console.log(chalk.green("Plan mode disabled."));
+        console.log(chalk.gray("Full tool access restored."));
+      } else {
+        manager.enable();
+        console.log(chalk.green("Plan mode enabled."));
+        console.log(chalk.gray("Tools are now read-only."));
+      }
+      return null;
+    default:
+      console.log(chalk.yellow(`Unknown subcommand: ${subcommand}`));
+      console.log(chalk.gray(`
+Usage:
+  /plan        - Toggle plan mode
+  /plan on     - Enable plan mode
+  /plan off    - Disable plan mode
+  /plan status - Show current plan state
+
+Keyboard shortcut:
+  Shift+Tab (twice) - Enter plan mode
+  Shift+Tab (once)  - Exit plan mode (when in plan mode)
+`));
+      return null;
+  }
+}
+function showPlanStatus(manager) {
+  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)")}`);
+  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("");
+    for (const step of plan2.steps) {
+      const icon = getStepIcon(step.status);
+      const color = getStepColor(step.status);
+      console.log(color(`  ${icon} ${step.number}. ${step.description}`));
+    }
+    if (inProgress) {
+      console.log("");
+      console.log(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."));
+  }
+  console.log("");
+  return null;
+}
+function getStepIcon(status) {
+  switch (status) {
+    case "completed":
+      return "\u2713";
+    case "in_progress":
+      return "\u2192";
+    case "skipped":
+      return "\u2298";
+    default:
+      return "\u25CB";
+  }
+}
+function getStepColor(status) {
+  switch (status) {
+    case "completed":
+      return chalk.green;
+    case "in_progress":
+      return chalk.yellow;
+    case "skipped":
+      return chalk.gray;
+    default:
+      return chalk.white;
+  }
+}
+
+export {
+  metadata,
+  getPlanModeManager,
+  plan
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Plan Mode Manager
+ * Central coordinator for plan mode state and operations
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Plan Mode Command
+ * Toggle plan mode for safe code exploration before execution
+ */

package/dist/chunk-NCLCL7JK.js

@@ -0,0 +1,63 @@
+import {
+  showConfirm,
+  showInput,
+  showModal,
+  showPassword
+} from "./chunk-6SM6N7DJ.js";
+
+// src/utils/prompt.ts
+async function safePrompt(questions) {
+  const questionArray = Array.isArray(questions) ? questions : [questions];
+  const results = {};
+  for (const question of questionArray) {
+    let value;
+    if (question.type === "select") {
+      const selectConfig = question;
+      const options = selectConfig.choices.map((choice) => ({
+        label: choice.message,
+        value: choice.name
+      }));
+      const result = await showModal({
+        title: selectConfig.message,
+        options,
+        initialIndex: selectConfig.initial
+      });
+      value = result?.value;
+    } else if (question.type === "confirm") {
+      const confirmConfig = question;
+      value = await showConfirm({
+        title: confirmConfig.message,
+        defaultValue: confirmConfig.initial
+      });
+    } else if (question.type === "password") {
+      const inputConfig = question;
+      value = await showPassword({
+        title: inputConfig.message,
+        validate: inputConfig.validate
+      });
+    } else if (question.type === "input") {
+      const inputConfig = question;
+      value = await showInput({
+        title: inputConfig.message,
+        defaultValue: inputConfig.initial,
+        validate: inputConfig.validate
+      });
+    }
+    if (value === null || value === void 0) {
+      return null;
+    }
+    results[question.name] = value;
+  }
+  return results;
+}
+
+export {
+  safePrompt
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Safe prompt utilities using Ink Modal components
+ */