autohand-cli 0.7.8 → 0.7.10

package/dist/chunk-ULQ6MDSJ.cjs

@@ -0,0 +1,362 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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/commands/plan.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+
+// src/modes/planMode/PlanModeManager.ts
+var _events = require('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 _events.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 = _optionalChain([args, 'optionalAccess', _ => _.trim, 'call', _2 => _2(), 'access', _3 => _3.toLowerCase, 'call', _4 => _4()]);
+  switch (subcommand) {
+    case "on":
+    case "enable":
+      if (manager.isEnabled()) {
+        console.log(_chalk2.default.yellow("Plan mode is already enabled."));
+        return null;
+      }
+      manager.enable();
+      console.log(_chalk2.default.green("Plan mode enabled."));
+      console.log(_chalk2.default.gray("Tools are now read-only. Use /plan off to disable."));
+      console.log(_chalk2.default.gray("Tip: Press Shift+Tab twice to quickly toggle plan mode."));
+      return null;
+    case "off":
+    case "disable":
+      if (!manager.isEnabled()) {
+        console.log(_chalk2.default.yellow("Plan mode is not enabled."));
+        return null;
+      }
+      manager.disable();
+      console.log(_chalk2.default.green("Plan mode disabled."));
+      console.log(_chalk2.default.gray("Full tool access restored."));
+      return null;
+    case "status":
+      return showPlanStatus(manager);
+    case "":
+    case void 0:
+      if (manager.isEnabled()) {
+        manager.disable();
+        console.log(_chalk2.default.green("Plan mode disabled."));
+        console.log(_chalk2.default.gray("Full tool access restored."));
+      } else {
+        manager.enable();
+        console.log(_chalk2.default.green("Plan mode enabled."));
+        console.log(_chalk2.default.gray("Tools are now read-only."));
+      }
+      return null;
+    default:
+      console.log(_chalk2.default.yellow(`Unknown subcommand: ${subcommand}`));
+      console.log(_chalk2.default.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(_chalk2.default.bold.cyan("Plan Mode Status"));
+  console.log(_chalk2.default.gray("\u2500".repeat(40)));
+  console.log(`Status:    ${enabled ? _chalk2.default.green("ENABLED") : _chalk2.default.gray("DISABLED")}`);
+  console.log(`Phase:     ${_chalk2.default.cyan(phase)}`);
+  console.log(`Indicator: ${indicator || _chalk2.default.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(_chalk2.default.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(_chalk2.default.yellow(`Currently working on: Step ${inProgress.number}`));
+    }
+  } else {
+    console.log("");
+    console.log(_chalk2.default.gray("No plan created yet."));
+    console.log(_chalk2.default.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 _chalk2.default.green;
+    case "in_progress":
+      return _chalk2.default.yellow;
+    case "skipped":
+      return _chalk2.default.gray;
+    default:
+      return _chalk2.default.white;
+  }
+}
+
+
+
+
+
+exports.metadata = metadata; exports.getPlanModeManager = getPlanModeManager; exports.plan = 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-WH3D42BQ.js → chunk-UM4QEO36.js}

@@ -1,14 +1,17 @@
 import {
   loadConfig,
   saveConfig
-} from "./chunk-GWIAMKKF.js";
+} from "./chunk-ZBIBLOZL.js";
+import {
+  t
+} from "./chunk-UET7BDX2.js";
 
 // src/commands/sync.ts
 import chalk from "chalk";
 import readline from "readline";
 var metadata = {
   command: "/sync",
-  description: "Manage settings sync (view status, enable/disable, trigger sync)",
+  description: t("commands.sync.description"),
   implemented: true
 };
 var globalSyncService = null;
@@ -62,7 +65,6 @@ function renderSyncUI(data, ctx) {
   return new Promise((resolve) => {
     const tabs = ["Status", "Settings", "Activity"];
     let currentTab = 0;
-    let needsRefresh = false;
     const input = process.stdin;
     const isTTY = input.isTTY;
     const wasRaw = input.isRaw;
@@ -85,94 +87,67 @@ function renderSyncUI(data, ctx) {
       renderTabContent(tabs[currentTab], data);
       console.log(chalk.gray("\nEsc to exit | Tab to cycle | s: sync now | e: toggle enabled"));
     };
-    let buffer = "";
-    const handler = async (chunk) => {
-      buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
-      const processNext = async () => {
-        if (!buffer.length) return false;
-        const first = buffer[0];
-        if (first === "\x1B") {
-          if (buffer.length === 1) return false;
-          if (buffer[1] === "[") {
-            if (buffer.length < 3) return false;
-            const seq = buffer.slice(0, 3);
-            buffer = buffer.slice(3);
-            await handleSequence(seq);
-            return true;
-          }
-          buffer = buffer.slice(1);
-          await handleSequence("\x1B");
-          return true;
-        }
-        buffer = buffer.slice(1);
-        await handleSequence(first);
-        return true;
-      };
-      while (await processNext()) {
+    const handler = async (_str, key) => {
+      const char = (_str || "").toLowerCase();
+      if (key.name === "escape" || key.name === "c" && key.ctrl) {
+        cleanup();
+        resolve();
+        return;
       }
-    };
-    const handleSequence = async (sequence) => {
-      switch (sequence) {
-        case "\x1B":
-        // ESC
-        case "":
-          cleanup();
-          resolve();
-          return;
-        case "	":
-        // Tab
-        case "\x1B[C":
-          currentTab = (currentTab + 1) % tabs.length;
-          render();
-          return;
-        case "\x1B[Z":
-        // Shift+Tab
-        case "\x1B[D":
-          currentTab = (currentTab - 1 + tabs.length) % tabs.length;
-          render();
-          return;
-        case "s":
-        case "S":
-          if (data.syncService) {
-            console.log(chalk.cyan("\nSyncing..."));
-            try {
-              const result = await data.syncService.sync();
-              if (result.success) {
-                console.log(chalk.green(`Sync complete! Uploaded: ${result.uploaded}, Downloaded: ${result.downloaded}`));
-              } else {
-                console.log(chalk.red(`Sync failed: ${result.error}`));
-              }
-              const config = await loadConfig();
-              Object.assign(data, await gatherSyncData(ctx, config));
-            } catch (err) {
-              console.log(chalk.red(`Sync error: ${err}`));
-            }
-            await sleep(1500);
-            render();
-          }
-          return;
-        case "e":
-        case "E":
+      if (key.name === "tab" && key.shift) {
+        currentTab = (currentTab - 1 + tabs.length) % tabs.length;
+        render();
+        return;
+      }
+      if (key.name === "tab" || key.name === "right") {
+        currentTab = (currentTab + 1) % tabs.length;
+        render();
+        return;
+      }
+      if (key.name === "left") {
+        currentTab = (currentTab - 1 + tabs.length) % tabs.length;
+        render();
+        return;
+      }
+      if (char === "s") {
+        if (data.syncService) {
+          console.log(chalk.cyan("\nSyncing..."));
           try {
+            const result = await data.syncService.sync();
+            if (result.success) {
+              console.log(chalk.green(`Sync complete! Uploaded: ${result.uploaded}, Downloaded: ${result.downloaded}`));
+            } else {
+              console.log(chalk.red(`Sync failed: ${result.error}`));
+            }
             const config = await loadConfig();
-            const newEnabled = config.sync?.enabled === false;
-            config.sync = { ...config.sync, enabled: newEnabled };
-            await saveConfig(config);
-            data.enabled = newEnabled;
-            console.log(chalk.cyan(`
-Sync ${newEnabled ? "enabled" : "disabled"}`));
-            await sleep(1e3);
-            render();
+            Object.assign(data, await gatherSyncData(ctx, config));
           } catch (err) {
-            console.log(chalk.red(`Error toggling sync: ${err}`));
+            console.log(chalk.red(`Sync error: ${err}`));
           }
-          return;
-        default:
-          return;
+          await sleep(1500);
+          render();
+        }
+        return;
+      }
+      if (char === "e") {
+        try {
+          const config = await loadConfig();
+          const newEnabled = config.sync?.enabled === false;
+          config.sync = { ...config.sync, enabled: newEnabled };
+          await saveConfig(config);
+          data.enabled = newEnabled;
+          console.log(chalk.cyan(`
+${newEnabled ? t("commands.sync.enabled") : t("commands.sync.disabled")}`));
+          await sleep(1e3);
+          render();
+        } catch (err) {
+          console.log(chalk.red(`Error toggling sync: ${err}`));
+        }
+        return;
       }
     };
     const cleanup = () => {
-      input.off("data", handler);
+      input.off("keypress", handler);
       if (isTTY && !wasRaw && typeof input.setRawMode === "function") {
         input.setRawMode(false);
       }
@@ -181,7 +156,7 @@ Sync ${newEnabled ? "enabled" : "disabled"}`));
       }
       process.stdout.write("\x1B[2J\x1B[H");
     };
-    input.on("data", handler);
+    input.on("keypress", handler);
     render();
   });
 }

package/dist/chunk-VXCMGBXY.cjs

@@ -0,0 +1,35 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/commands/cc.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+async function cc(ctx) {
+  if (!ctx.toggleContextCompaction || !ctx.isContextCompactionEnabled) {
+    console.log(_chalk2.default.yellow("Context compaction is not available in this mode."));
+    return null;
+  }
+  ctx.toggleContextCompaction();
+  const enabled = ctx.isContextCompactionEnabled();
+  const status = enabled ? "enabled" : "disabled";
+  const color = enabled ? _chalk2.default.green : _chalk2.default.yellow;
+  console.log(color(`Context compaction ${status}`));
+  if (!enabled) {
+    console.log(_chalk2.default.gray('  Note: Without compaction, you may see "context too long" errors.'));
+    console.log(_chalk2.default.gray("  Use /cc again to re-enable auto-compaction."));
+  } else {
+    console.log(_chalk2.default.gray("  Auto-compacting context at 70%/80%/90% thresholds."));
+  }
+  return null;
+}
+var metadata = {
+  command: "/cc",
+  description: "toggle context compaction on/off",
+  implemented: true
+};
+
+
+
+
+exports.cc = cc; exports.metadata = metadata;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-WD5ZF6HE.js

@@ -0,0 +1,63 @@
+import {
+  showConfirm,
+  showInput,
+  showModal,
+  showPassword
+} from "./chunk-PNSRJT46.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
+ */