autohand-cli 0.8.3 → 0.9.1

package/dist/chunk-B4HSNOIH.cjs

@@ -0,0 +1,354 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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/context/priority.ts
+function extractMessageMetadata(message) {
+  const content = _nullishCoalesce(message.content, () => ( ""));
+  const metadata = {};
+  const filePatterns = [
+    /(?:^|\s)([\/\w.-]+\.[a-zA-Z]{1,5})(?:\s|$|:|\()/gm,
+    /`([^`]+\.[a-zA-Z]{1,5})`/g,
+    /["']([^"']+\.[a-zA-Z]{1,5})["']/g
+  ];
+  const files = /* @__PURE__ */ new Set();
+  for (const pattern of filePatterns) {
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      const file = match[1];
+      if (file && !file.startsWith("http") && !file.includes("://")) {
+        files.add(file);
+      }
+    }
+  }
+  if (files.size > 0) {
+    metadata.files = [...files];
+  }
+  if (message.name) {
+    metadata.tools = [message.name];
+  }
+  if (message.tool_calls && message.tool_calls.length > 0) {
+    metadata.tools = message.tool_calls.map((tc) => tc.function.name);
+  }
+  const decisionPatterns = [
+    /I('ll| will|'m going to| chose| decided| picked| selected)/i,
+    /let's (use|go with|implement|create)/i,
+    /we should (use|implement|create|add)/i,
+    /the (best|better|recommended) (approach|option|choice)/i
+  ];
+  metadata.isDecision = decisionPatterns.some((p) => p.test(content));
+  const errorPatterns = [
+    /error:|failed:|exception:|crash|bug|issue:|problem:/i,
+    /TypeError|SyntaxError|ReferenceError|Error:/,
+    /❌|✗|FAIL|FAILED/
+  ];
+  metadata.isError = errorPatterns.some((p) => p.test(content));
+  return metadata;
+}
+function determineMessagePriority(message) {
+  const content = _nullishCoalesce(message.content, () => ( ""));
+  const metadata = _nullishCoalesce(message.metadata, () => ( extractMessageMetadata(message)));
+  if (message.role === "system") {
+    return "critical";
+  }
+  if (message.role === "user") {
+    if (metadata.isDecision) return "critical";
+    if (content.length < 100) return "high";
+    return "high";
+  }
+  if (metadata.isError) {
+    return "high";
+  }
+  if (message.role === "tool" && metadata.files && metadata.files.length > 0) {
+    return "medium";
+  }
+  if (message.role === "tool" && content.length > 2e3) {
+    return "low";
+  }
+  if (message.role === "assistant" && metadata.isDecision) {
+    return "high";
+  }
+  return "medium";
+}
+function sortMessagesByPriority(messages) {
+  const priorityOrder = {
+    "low": 0,
+    "medium": 1,
+    "high": 2,
+    "critical": 3
+  };
+  const indices = messages.map((msg, i) => ({
+    index: i,
+    priority: _nullishCoalesce(msg.priority, () => ( determineMessagePriority(msg))),
+    age: i
+  }));
+  indices.sort((a, b) => {
+    const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
+    if (priorityDiff !== 0) return priorityDiff;
+    return a.age - b.age;
+  });
+  return indices.map((i) => i.index);
+}
+function findCoherentRemovalIndices(messages, targetIndices) {
+  const toRemove = new Set(targetIndices);
+  for (const idx of [...toRemove]) {
+    const msg = messages[idx];
+    if (msg.role === "tool" && msg.tool_call_id) {
+      const assistantIdx = messages.findIndex(
+        (m) => m.role === "assistant" && _optionalChain([m, 'access', _ => _.tool_calls, 'optionalAccess', _2 => _2.some, 'call', _3 => _3((tc) => tc.id === msg.tool_call_id)])
+      );
+      if (assistantIdx >= 0) toRemove.add(assistantIdx);
+    }
+  }
+  for (const idx of [...toRemove]) {
+    const msg = messages[idx];
+    if (msg.role === "assistant" && msg.tool_calls) {
+      for (const tc of msg.tool_calls) {
+        const toolIdx = messages.findIndex(
+          (m) => m.role === "tool" && m.tool_call_id === tc.id
+        );
+        if (toolIdx >= 0) toRemove.add(toolIdx);
+      }
+    }
+  }
+  return [...toRemove].sort((a, b) => a - b);
+}
+
+// src/core/context/serializer.ts
+var TOOL_RESULT_MAX_LENGTH = 2e3;
+function serializeMessagesForSummary(messages) {
+  const lines = [];
+  for (const msg of messages) {
+    switch (msg.role) {
+      case "system":
+        break;
+      case "user":
+        lines.push(`[User]: ${_nullishCoalesce(msg.content, () => ( ""))}`);
+        break;
+      case "assistant": {
+        const content = _nullishCoalesce(msg.content, () => ( ""));
+        if (msg.tool_calls && msg.tool_calls.length > 0) {
+          const callDescriptions = msg.tool_calls.map((tc) => {
+            const args = _nullishCoalesce(tc.function.arguments, () => ( "{}"));
+            let shortArgs = args;
+            try {
+              const parsed = JSON.parse(args);
+              const keys = Object.keys(parsed);
+              const preview = keys.slice(0, 3).map((k) => `${k}="${String(parsed[k]).slice(0, 80)}"`).join(", ");
+              shortArgs = keys.length > 3 ? `${preview}, +${keys.length - 3} more` : preview;
+            } catch (e) {
+              shortArgs = args.slice(0, 100);
+            }
+            return `${tc.function.name}(${shortArgs})`;
+          }).join("; ");
+          if (content) {
+            lines.push(`[Assistant]: ${content.slice(0, 500)}`);
+          }
+          lines.push(`[Assistant tool calls]: ${callDescriptions}`);
+        } else {
+          lines.push(`[Assistant]: ${content.slice(0, 500)}`);
+        }
+        break;
+      }
+      case "tool": {
+        const toolName = _nullishCoalesce(msg.name, () => ( "unknown"));
+        const rawContent = _nullishCoalesce(msg.content, () => ( ""));
+        const truncated = rawContent.length > TOOL_RESULT_MAX_LENGTH ? rawContent.slice(0, Math.floor(TOOL_RESULT_MAX_LENGTH * 0.6)) + `
+... [${rawContent.length - TOOL_RESULT_MAX_LENGTH} chars truncated] ...
+` + rawContent.slice(-Math.floor(TOOL_RESULT_MAX_LENGTH * 0.3)) : rawContent;
+        lines.push(`[Tool result (${toolName})]: ${truncated}`);
+        break;
+      }
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/core/context/summarizer.ts
+function summarizeMessagesStatic(messages) {
+  const files = /* @__PURE__ */ new Set();
+  const tools = /* @__PURE__ */ new Set();
+  const decisions = [];
+  const errors = [];
+  const userRequests = [];
+  for (const msg of messages) {
+    const metadata = _nullishCoalesce(msg.metadata, () => ( extractMessageMetadata(msg)));
+    if (metadata.files) {
+      metadata.files.forEach((f) => files.add(f));
+    }
+    if (metadata.tools) {
+      metadata.tools.forEach((t) => tools.add(t));
+    }
+    if (msg.role === "user") {
+      const preview = (_nullishCoalesce(msg.content, () => ( ""))).slice(0, 100);
+      userRequests.push(preview + (preview.length < (_nullishCoalesce(_optionalChain([msg, 'access', _4 => _4.content, 'optionalAccess', _5 => _5.length]), () => ( 0))) ? "..." : ""));
+    }
+    if (metadata.isDecision && msg.role === "assistant") {
+      const preview = (_nullishCoalesce(msg.content, () => ( ""))).slice(0, 150);
+      decisions.push(preview);
+    }
+    if (metadata.isError) {
+      const preview = (_nullishCoalesce(msg.content, () => ( ""))).slice(0, 150);
+      errors.push(preview);
+    }
+  }
+  const parts = [
+    `[Context Summary - ${messages.length} messages condensed]`
+  ];
+  if (userRequests.length > 0) {
+    parts.push(`User requests: ${userRequests.slice(0, 3).join(" | ")}`);
+  }
+  if (files.size > 0) {
+    parts.push(`Files touched: ${[...files].slice(0, 10).join(", ")}${files.size > 10 ? ` (+${files.size - 10} more)` : ""}`);
+  }
+  if (tools.size > 0) {
+    parts.push(`Tools used: ${[...tools].join(", ")}`);
+  }
+  if (decisions.length > 0) {
+    parts.push(`Key decisions: ${decisions.slice(0, 2).join(" | ")}`);
+  }
+  if (errors.length > 0) {
+    parts.push(`Errors encountered: ${errors.slice(0, 2).join(" | ")}`);
+  }
+  return parts.join("\n");
+}
+async function summarizeWithLLM(messages, llm, memoryManager) {
+  if (!llm || messages.length === 0) {
+    return summarizeMessagesStatic(messages);
+  }
+  try {
+    const serializedLog = serializeMessagesForSummary(messages);
+    const summarizationPrompt = [
+      "Summarize the following conversation for context preservation. Include:",
+      "1. The user's original request and intent",
+      "2. What has been accomplished so far (files created/modified, commands run)",
+      "3. What remains to be done",
+      "4. Any key decisions or constraints discovered",
+      "5. Any user preferences or project-relevant points worth remembering",
+      "",
+      "Keep it concise (under 500 words). This summary replaces the removed messages.",
+      "",
+      "--- Conversation ---",
+      serializedLog
+    ].join("\n");
+    const response = await llm.complete({
+      messages: [
+        { role: "system", content: "You are a context summarization assistant. Produce concise, factual summaries that preserve task continuity." },
+        { role: "user", content: summarizationPrompt }
+      ],
+      temperature: 0.1,
+      maxTokens: 1e3
+    });
+    const summaryText = _optionalChain([response, 'access', _6 => _6.content, 'optionalAccess', _7 => _7.trim, 'call', _8 => _8()]);
+    if (!summaryText) {
+      return summarizeMessagesStatic(messages);
+    }
+    if (memoryManager) {
+      await persistKeyFacts(summaryText, memoryManager).catch(() => {
+      });
+    }
+    return `[LLM Context Summary - ${messages.length} messages condensed]
+${summaryText}`;
+  } catch (e2) {
+    return summarizeMessagesStatic(messages);
+  }
+}
+function buildStructuredSummary(summaryText, fileOps) {
+  const lines = summaryText.split("\n").map((l) => l.trim()).filter(Boolean);
+  const goal = _nullishCoalesce(_nullishCoalesce(lines.find((l) => /goal|intent|request|objective/i.test(l)), () => ( lines[0])), () => ( ""));
+  const constraints = [];
+  const progress = [];
+  const keyDecisions = [];
+  const nextSteps = [];
+  const criticalContext = [];
+  for (const line of lines) {
+    if (/constraint|requirement|must|should/i.test(line)) constraints.push(line);
+    else if (/accomplished|done|completed|created|modified|implemented/i.test(line)) progress.push(line);
+    else if (/decided|chose|selected|preference/i.test(line)) keyDecisions.push(line);
+    else if (/remain|todo|next|pending|still/i.test(line)) nextSteps.push(line);
+    else if (/critical|important|essential|key/i.test(line)) criticalContext.push(line);
+  }
+  return {
+    goal,
+    constraints,
+    progress,
+    keyDecisions,
+    nextSteps,
+    criticalContext,
+    readFiles: fileOps.readFiles,
+    modifiedFiles: fileOps.modifiedFiles
+  };
+}
+function extractFileOperations(messages) {
+  const readFiles = /* @__PURE__ */ new Set();
+  const modifiedFiles = /* @__PURE__ */ new Set();
+  for (const msg of messages) {
+    const metadata = _nullishCoalesce(msg.metadata, () => ( extractMessageMetadata(msg)));
+    if (!metadata.tools || !metadata.files) continue;
+    for (const tool of metadata.tools) {
+      const isReadTool = tool.includes("read") || tool.includes("cat") || tool.includes("grep") || tool.includes("search");
+      const isWriteTool = tool.includes("write") || tool.includes("edit") || tool.includes("create") || tool.includes("delete") || tool.includes("move");
+      if (isReadTool) {
+        metadata.files.forEach((f) => readFiles.add(f));
+      }
+      if (isWriteTool) {
+        metadata.files.forEach((f) => modifiedFiles.add(f));
+      }
+    }
+  }
+  return {
+    readFiles: [...readFiles],
+    modifiedFiles: [...modifiedFiles]
+  };
+}
+async function persistKeyFacts(summary, memoryManager) {
+  const factPatterns = [
+    /(?:chose|decided|selected|using|preference|prefer)\s+.{10,100}/gi,
+    /(?:constraint|requirement|must|should)\s+.{10,100}/gi
+  ];
+  const facts = /* @__PURE__ */ new Set();
+  for (const pattern of factPatterns) {
+    let match;
+    while ((match = pattern.exec(summary)) !== null) {
+      facts.add(match[0].trim());
+    }
+  }
+  for (const fact of [...facts].slice(0, 5)) {
+    await memoryManager.store(fact, "project", ["context-summary"], "context-summarization");
+  }
+}
+var summarizeMessages = summarizeMessagesStatic;
+
+
+
+
+
+
+
+
+
+
+
+
+exports.extractMessageMetadata = extractMessageMetadata; exports.determineMessagePriority = determineMessagePriority; exports.sortMessagesByPriority = sortMessagesByPriority; exports.findCoherentRemovalIndices = findCoherentRemovalIndices; exports.summarizeMessagesStatic = summarizeMessagesStatic; exports.summarizeWithLLM = summarizeWithLLM; exports.buildStructuredSummary = buildStructuredSummary; exports.extractFileOperations = extractFileOperations; exports.persistKeyFacts = persistKeyFacts; exports.summarizeMessages = summarizeMessages;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Metadata extraction, priority scoring, sorting, and tool-call coherence.
+ * Extracted from contextManager.ts for composability.
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Message → text serialization for summarization prompts.
+ * Converts LLMMessage[] into a plain-text conversation log that
+ * prevents the LLM from treating it as a conversation to continue.
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * LLM-powered + static summarization with structured format.
+ * Extracted from contextManager.ts for composability.
+ */

package/dist/chunk-B76FJKEJ.cjs

@@ -0,0 +1,184 @@
+"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 _chunkNQZH5CR2cjs = require('./chunk-NQZH5CR2.cjs');
+
+
+
+var _chunkWJYFLQ7Gcjs = require('./chunk-WJYFLQ7G.cjs');
+
+// src/commands/goal.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+var metadata = {
+  command: "/goal",
+  description: "Create, inspect, pause, resume, complete, clear, and queue persistent goals",
+  implemented: true,
+  subcommands: [
+    { name: "queue", description: "List queued goals or enqueue a goal" },
+    { name: "pause", description: "Pause the current goal" },
+    { name: "resume", description: "Resume a paused or queued goal" },
+    { name: "complete", description: "Mark the current goal complete" },
+    { name: "clear", description: "Clear the current goal" },
+    { name: "templates", description: "List reusable .pi-goals templates" }
+  ]
+};
+async function goal(ctx, args = []) {
+  if (!_chunkWJYFLQ7Gcjs.resolveGoalFeatureEnabled.call(void 0, ctx.config, ctx.isFeatureEnabled)) {
+    return _chunkWJYFLQ7Gcjs.GOAL_FEATURE_DISABLED_MESSAGE;
+  }
+  await _optionalChain([ctx, 'access', _ => _.trackFeatureActivation, 'optionalCall', _2 => _2("slash_goal", { surface: "slash_command" })]);
+  const manager = new (0, _chunkNQZH5CR2cjs.GoalManager)(ctx.workspaceRoot);
+  const input = args.join(" ").trim();
+  if (!input) {
+    return formatSnapshot(await manager.getSnapshot());
+  }
+  const [subcommand, ...restArgs] = args;
+  const rest = restArgs.join(" ").trim();
+  switch (_optionalChain([subcommand, 'optionalAccess', _3 => _3.toLowerCase, 'call', _4 => _4()])) {
+    case "queue":
+      return handleQueue(manager, rest);
+    case "pause":
+      return formatMutation(await manager.updateGoal({ status: "paused" }));
+    case "resume": {
+      const snapshot = await manager.getSnapshot();
+      if (!snapshot.goal && snapshot.queue.length > 0) {
+        const started = await manager.startQueuedGoal();
+        if (started.ok && started.goal) {
+          queueGoalContinuation(ctx, started.goal.objective);
+        }
+        return formatMutation(started);
+      }
+      const resumed = await manager.updateGoal({ status: "active" });
+      if (resumed.ok && resumed.goal) {
+        queueGoalContinuation(ctx, resumed.goal.objective);
+      }
+      return formatMutation(resumed);
+    }
+    case "complete":
+      return formatMutation(await manager.updateGoal({ status: "complete" }));
+    case "clear":
+      return formatMutation(await manager.clearGoal());
+    case "templates": {
+      const templates = await manager.listTemplates();
+      if (templates.length === 0) return "No goal templates found in .pi-goals/ or .ai/.pi-goals/.";
+      return [
+        `Goal templates (${templates.length}):`,
+        ...templates.map((template) => {
+          const aliases = template.aliases.length ? ` aliases: ${template.aliases.join(", ")}` : "";
+          return `- ${template.name}${aliases}${template.description ? ` - ${template.description}` : ""}`;
+        })
+      ].join("\n");
+    }
+    default: {
+      const resolved = await manager.resolveObjective(input);
+      if (!resolved.ok) return _chalk2.default.yellow(resolved.message);
+      const created = await manager.createGoal(resolved.input, { replace: false });
+      if (created.ok && created.goal) {
+        queueGoalContinuation(ctx, created.goal.objective);
+      }
+      return formatMutation(created);
+    }
+  }
+}
+async function runGoalCli(workspaceRoot, rawInput, config) {
+  if (!_chunkWJYFLQ7Gcjs.resolveGoalFeatureEnabled.call(void 0, config)) {
+    return _chunkWJYFLQ7Gcjs.GOAL_FEATURE_DISABLED_MESSAGE;
+  }
+  const manager = new (0, _chunkNQZH5CR2cjs.GoalManager)(workspaceRoot);
+  const input = _nullishCoalesce(_optionalChain([rawInput, 'optionalAccess', _5 => _5.trim, 'call', _6 => _6()]), () => ( ""));
+  if (!input) return formatSnapshot(await manager.getSnapshot());
+  const args = _nullishCoalesce(_optionalChain([input, 'access', _7 => _7.match, 'call', _8 => _8(/"[^"]*"|'[^']*'|\S+/g), 'optionalAccess', _9 => _9.map, 'call', _10 => _10(unquote)]), () => ( []));
+  return goal({ workspaceRoot }, args);
+}
+async function handleQueue(manager, rest) {
+  if (!rest) {
+    const snapshot = await manager.getSnapshot();
+    if (snapshot.queue.length === 0) return "No queued goals.";
+    return formatQueue(snapshot);
+  }
+  return formatMutation(await manager.enqueueGoalBlock(rest, "command"));
+}
+function queueGoalContinuation(ctx, objective) {
+  _optionalChain([ctx, 'access', _11 => _11.queueInstruction, 'optionalCall', _12 => _12([
+    `Active goal: ${objective}`,
+    "Continue working toward this persistent goal until it is complete, blocked, paused, cleared, or budget-limited.",
+    "Use get_goal or update_goal when you need to inspect or modify the goal state."
+  ].join("\n"))]);
+}
+function formatMutation(result) {
+  const lines = [result.ok ? _chalk2.default.green(_nullishCoalesce(result.message, () => ( "Goal updated."))) : _chalk2.default.yellow(_nullishCoalesce(result.message, () => ( "Goal command failed.")))];
+  if (result.goal) {
+    lines.push("");
+    lines.push(formatGoal(result.goal));
+  }
+  if (_optionalChain([result, 'access', _13 => _13.queued, 'optionalAccess', _14 => _14.length])) {
+    lines.push("");
+    lines.push(`Queued ${result.queued.length} goal${result.queued.length === 1 ? "" : "s"}:`);
+    for (const item of result.queued) {
+      lines.push(`- [${item.queueId}] ${item.objective}`);
+    }
+  }
+  if (result.started) {
+    lines.push(`Started queue item: ${result.started.queueId}`);
+  }
+  if (result.queue.length > 0 && !_optionalChain([result, 'access', _15 => _15.queued, 'optionalAccess', _16 => _16.length])) {
+    lines.push("");
+    lines.push(formatQueue({ queue: result.queue }));
+  }
+  return lines.join("\n");
+}
+function formatSnapshot(snapshot) {
+  if (!snapshot.goal && snapshot.queue.length === 0) {
+    return [
+      "No goal is currently set.",
+      "Use /goal <objective> to create one, or /goal queue <objective> to queue later work."
+    ].join("\n");
+  }
+  const parts = [];
+  if (snapshot.goal) parts.push(formatGoal(snapshot.goal));
+  else parts.push("No active goal.");
+  if (snapshot.queue.length > 0) {
+    parts.push("");
+    parts.push(formatQueue(snapshot));
+  }
+  return parts.join("\n");
+}
+function formatGoal(goalState) {
+  const lines = [
+    `Goal: ${goalState.objective}`,
+    `Status: ${goalState.status}`,
+    `ID: ${goalState.goalId}`,
+    `Elapsed: ${formatDuration(goalState.timeUsedSeconds)}`,
+    `Tokens: ${goalState.tokensUsed}${goalState.tokenBudget ? ` / ${goalState.tokenBudget}` : ""}`
+  ];
+  if (goalState.timeBudgetSeconds) lines.push(`Time budget: ${formatDuration(goalState.timeBudgetSeconds)}`);
+  if (goalState.minTokensBeforeWrapUp) lines.push(`Token floor: ${goalState.minTokensBeforeWrapUp}`);
+  if (goalState.minTimeSecondsBeforeWrapUp) lines.push(`Time floor: ${formatDuration(goalState.minTimeSecondsBeforeWrapUp)}`);
+  return lines.join("\n");
+}
+function formatQueue(snapshot) {
+  if (snapshot.queue.length === 0) return "No queued goals.";
+  return [
+    `Queued goals (${snapshot.queue.length}):`,
+    ...snapshot.queue.map((item, index) => `${index + 1}. [${item.queueId}] ${item.objective}`)
+  ].join("\n");
+}
+function formatDuration(seconds) {
+  const whole = Math.max(0, Math.floor(seconds));
+  const minutes = Math.floor(whole / 60);
+  const secs = whole % 60;
+  return minutes > 0 ? `${minutes}m ${secs}s` : `${secs}s`;
+}
+function unquote(value) {
+  return value.replace(/^['"]|['"]$/g, "");
+}
+
+
+
+
+
+exports.metadata = metadata; exports.goal = goal; exports.runGoalCli = runGoalCli;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-BP37FVBM.js

@@ -0,0 +1,85 @@
+import {
+  SetupWizard
+} from "./chunk-HSWWM6AM.js";
+import {
+  loadConfig,
+  resolveWorkspaceRoot,
+  saveConfig
+} from "./chunk-IEPLQ47J.js";
+import {
+  detectLocale,
+  initI18n,
+  t
+} from "./chunk-LEZEWKPA.js";
+
+// src/commands/setup.ts
+import chalk from "chalk";
+var metadata = {
+  command: "/setup",
+  description: t("commands.setup.description") ?? "Run the setup wizard to configure or reconfigure Autohand",
+  implemented: true
+};
+async function setup(ctx) {
+  if (ctx.isNonInteractive) {
+    return t("commands.setup.interactiveOnly") ?? "Setup requires an interactive terminal. Use the --setup CLI flag instead.";
+  }
+  const { locale: detectedLocale } = detectLocale();
+  const locale = detectedLocale ?? "en";
+  await initI18n(locale);
+  const config = await loadConfig(ctx.config?.configPath, ctx.workspaceRoot);
+  const workspaceRoot = resolveWorkspaceRoot(config, ctx.workspaceRoot);
+  if (ctx.eventEmitter) {
+    ctx.eventEmitter.emit("setup:started", {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      locale,
+      workspaceRoot
+    });
+  }
+  const wizard = new SetupWizard(workspaceRoot, config);
+  const result = await wizard.run({ force: true, skipWelcome: false });
+  if (result.cancelled) {
+    if (ctx.eventEmitter) {
+      ctx.eventEmitter.emit("setup:cancelled", {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        step: "user_cancelled"
+      });
+    }
+    return t("commands.setup.cancelled") ?? "Setup cancelled.";
+  }
+  if (!result.success) {
+    if (ctx.eventEmitter) {
+      ctx.eventEmitter.emit("setup:error", {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        error: "setup_failed"
+      });
+    }
+    return t("commands.setup.failed") ?? "Setup failed. Please try again.";
+  }
+  const newConfig = { ...config, ...result.config };
+  await saveConfig(newConfig);
+  if (ctx.eventEmitter) {
+    const provider = result.config.provider;
+    const providerConfig = provider && result.config[provider];
+    const model = providerConfig && typeof providerConfig === "object" && "model" in providerConfig ? providerConfig.model : void 0;
+    ctx.eventEmitter.emit("setup:complete", {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      success: true,
+      provider,
+      model,
+      skippedSteps: result.skippedSteps,
+      agentsFileCreated: result.agentsFileCreated
+    });
+  }
+  console.log(chalk.green(t("commands.setup.complete") ?? "\nSetup complete!"));
+  return null;
+}
+
+export {
+  metadata,
+  setup
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-BQU3HAE7.js

@@ -0,0 +1,21 @@
+// src/ui/rawMode.ts
+function safeSetRawMode(input, mode) {
+  if (!input?.isTTY || typeof input.setRawMode !== "function") {
+    return false;
+  }
+  try {
+    input.setRawMode(mode);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  safeSetRawMode
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */