autohand-cli 0.7.8 → 0.7.10

package/dist/chunk-MNCWB5F7.cjs

@@ -0,0 +1,63 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkQRQ5EX7Icjs = require('./chunk-QRQ5EX7I.cjs');
+
+// 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 _chunkQRQ5EX7Icjs.showModal.call(void 0, {
+        title: selectConfig.message,
+        options,
+        initialIndex: selectConfig.initial
+      });
+      value = _optionalChain([result, 'optionalAccess', _ => _.value]);
+    } else if (question.type === "confirm") {
+      const confirmConfig = question;
+      value = await _chunkQRQ5EX7Icjs.showConfirm.call(void 0, {
+        title: confirmConfig.message,
+        defaultValue: confirmConfig.initial
+      });
+    } else if (question.type === "password") {
+      const inputConfig = question;
+      value = await _chunkQRQ5EX7Icjs.showPassword.call(void 0, {
+        title: inputConfig.message,
+        validate: inputConfig.validate
+      });
+    } else if (question.type === "input") {
+      const inputConfig = question;
+      value = await _chunkQRQ5EX7Icjs.showInput.call(void 0, {
+        title: inputConfig.message,
+        defaultValue: inputConfig.initial,
+        validate: inputConfig.validate
+      });
+    }
+    if (value === null || value === void 0) {
+      return null;
+    }
+    results[question.name] = value;
+  }
+  return results;
+}
+
+
+
+exports.safePrompt = safePrompt;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Safe prompt utilities using Ink Modal components
+ */

package/dist/{chunk-AVL4DKQO.js → chunk-MYNHJHDZ.js}

@@ -1,6 +1,6 @@
 import {
   AUTOHAND_PATHS
-} from "./chunk-EKY5PKQI.js";
+} from "./chunk-PWLLLJHU.js";
 
 // src/session/SessionManager.ts
 import fs from "fs-extra";

package/dist/{chunk-GDTZQSJ6.cjs → chunk-N4ZSG6JJ.cjs}

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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 _chunkPMMSDR44cjs = require('./chunk-PMMSDR44.cjs');
+var _chunkGIZL57FEcjs = require('./chunk-GIZL57FE.cjs');
 
 // src/skills/CommunitySkillsCache.ts
 var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
@@ -9,7 +9,7 @@ var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
 var DEFAULT_MAX_SKILLS_CACHE = 50;
 var CommunitySkillsCache = class {
   constructor(config = {}) {
-    this.cacheDir = config.cacheDir || _path2.default.join(_chunkPMMSDR44cjs.AUTOHAND_HOME, "community-skills", "cache");
+    this.cacheDir = config.cacheDir || _path2.default.join(_chunkGIZL57FEcjs.AUTOHAND_HOME, "community-skills", "cache");
     this.ttlMs = _nullishCoalesce(config.ttlMs, () => ( DEFAULT_TTL_MS));
     this.maxSkillsCache = _nullishCoalesce(config.maxSkillsCache, () => ( DEFAULT_MAX_SKILLS_CACHE));
   }

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-NF7RIHJK.js

@@ -0,0 +1,45 @@
+import {
+  getCurrentLocale,
+  onLanguageChange,
+  t
+} from "./chunk-UET7BDX2.js";
+
+// src/ui/i18n/I18nContext.tsx
+import { createContext, useContext, useState, useEffect, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+var defaultContextValue = {
+  t,
+  locale: "en"
+};
+var I18nContext = createContext(defaultContextValue);
+var I18nProvider = ({ children }) => {
+  const [locale, setLocale] = useState(getCurrentLocale());
+  useEffect(() => {
+    const unsubscribe = onLanguageChange((newLocale) => {
+      setLocale(newLocale);
+    });
+    return unsubscribe;
+  }, []);
+  const value = useMemo(
+    () => ({
+      t,
+      locale
+    }),
+    [locale]
+  );
+  return /* @__PURE__ */ jsx(I18nContext.Provider, { value, children });
+};
+function useTranslation() {
+  const context = useContext(I18nContext);
+  return context;
+}
+
+export {
+  I18nProvider,
+  useTranslation
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */