autohand-cli 0.6.3 → 0.6.4

package/dist/chunk-RDEROLKA.cjs

@@ -0,0 +1,79 @@
+"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 _chunkIHJDYAYJcjs = require('./chunk-IHJDYAYJ.cjs');
+
+// src/commands/feedback.ts
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+var _enquirer = require('enquirer'); var _enquirer2 = _interopRequireDefault(_enquirer);
+var metadata = {
+  command: "/feedback",
+  description: "share feedback with environment details",
+  implemented: true
+};
+async function feedback(_ctx) {
+  const answer = await _enquirer2.default.prompt([
+    {
+      type: "input",
+      name: "feedback",
+      message: "What worked? What broke?"
+    }
+  ]);
+  if (!_optionalChain([answer, 'access', _ => _.feedback, 'optionalAccess', _2 => _2.trim, 'call', _3 => _3()])) {
+    console.log(_chalk2.default.gray("Feedback discarded (empty)."));
+    return null;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const runtimeError = getLastRuntimeError();
+  const payload = {
+    timestamp: now,
+    feedback: answer.feedback.trim(),
+    env: {
+      platform: `${process.platform}-${process.arch}`,
+      node: process.version,
+      bun: _optionalChain([process, 'access', _4 => _4.versions, 'optionalAccess', _5 => _5.bun]),
+      cwd: process.cwd(),
+      shell: process.env.SHELL
+    },
+    runtimeError: runtimeError ? formatError(runtimeError) : null
+  };
+  try {
+    const feedbackPath = _chunkIHJDYAYJcjs.AUTOHAND_FILES.feedbackLog;
+    await _fsextra2.default.ensureFile(feedbackPath);
+    await _fsextra2.default.appendFile(feedbackPath, JSON.stringify(payload) + "\n", "utf8");
+    console.log(_chalk2.default.green("Feedback recorded."));
+    console.log(_chalk2.default.gray(`Saved to ${feedbackPath}`));
+  } catch (error) {
+    console.error(_chalk2.default.red(`Failed to save feedback: ${error.message}`));
+  }
+  if (runtimeError) {
+    console.log(_chalk2.default.yellow("Detected a recent runtime error; included in feedback payload."));
+  }
+  return null;
+}
+function getLastRuntimeError() {
+  const globalAny = globalThis;
+  return _nullishCoalesce(globalAny.__autohandLastError, () => ( null));
+}
+function formatError(err) {
+  if (!err) return {};
+  if (err instanceof Error) {
+    return { message: err.message, stack: err.stack };
+  }
+  if (typeof err === "object") {
+    const message = "message" in err ? String(err.message) : void 0;
+    const stack = "stack" in err ? String(err.stack) : void 0;
+    return { message, stack };
+  }
+  return { message: String(err) };
+}
+
+
+
+
+exports.metadata = metadata; exports.feedback = feedback;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-RYY5I7QN.cjs

@@ -0,0 +1,49 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/commands/resume.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+var metadata = {
+  command: "/resume",
+  description: "resume a previous session",
+  implemented: true
+};
+async function resume(ctx) {
+  const sessionId = ctx.args[0];
+  if (!sessionId) {
+    console.log(_chalk2.default.red("Usage: /resume <session-id>"));
+    console.log(_chalk2.default.gray("Use /sessions to list available sessions"));
+    return null;
+  }
+  try {
+    const session = await ctx.sessionManager.loadSession(sessionId);
+    const messages = session.getMessages();
+    console.log(_chalk2.default.cyan(`
+\u{1F4C2} Resuming session ${sessionId}`));
+    console.log(_chalk2.default.gray(`   Project: ${session.metadata.projectPath}`));
+    console.log(_chalk2.default.gray(`   Started: ${new Date(session.metadata.createdAt).toLocaleString()}`));
+    console.log(_chalk2.default.gray(`   Messages: ${messages.length}`));
+    console.log();
+    if (messages.length > 0) {
+      console.log(_chalk2.default.cyan("Recent conversation:"));
+      const recentMessages = messages.slice(-3);
+      for (const msg of recentMessages) {
+        const role = msg.role === "user" ? _chalk2.default.green("You") : _chalk2.default.blue("Assistant");
+        const preview = msg.content.slice(0, 80) + (msg.content.length > 80 ? "..." : "");
+        console.log(`${role}: ${_chalk2.default.gray(preview)}`);
+      }
+      console.log();
+    }
+    return "SESSION_RESUMED";
+  } catch (error) {
+    console.error(_chalk2.default.red(`Failed to resume session: ${error.message}`));
+    return null;
+  }
+}
+
+
+
+
+exports.metadata = metadata; exports.resume = resume;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-V5MTBGM4.cjs

@@ -0,0 +1,20 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/commands/init.ts
+async function init(ctx) {
+  await ctx.createAgentsFile();
+  return null;
+}
+var metadata = {
+  command: "/init",
+  description: "create an AGENTS.md file with instructions for Autohand",
+  implemented: true
+};
+
+
+
+
+exports.init = init; exports.metadata = metadata;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-VMMGT42E.cjs

@@ -0,0 +1,60 @@
+"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/sessions.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+var metadata = {
+  command: "/sessions",
+  description: "list all sessions",
+  implemented: true
+};
+async function sessions(ctx) {
+  const projectFilter = ctx.args.includes("--project") ? ctx.args[ctx.args.indexOf("--project") + 1] : void 0;
+  try {
+    const allSessions = await ctx.sessionManager.listSessions(
+      projectFilter ? { project: projectFilter } : void 0
+    );
+    if (allSessions.length === 0) {
+      console.log(_chalk2.default.gray("No sessions found."));
+      return null;
+    }
+    console.log(_chalk2.default.cyan(`
+Sessions${projectFilter ? ` for ${projectFilter}` : ""}:
+`));
+    console.log(
+      _chalk2.default.bold(
+        " ID".padEnd(25) + "Created".padEnd(20) + "Messages".padEnd(12) + "Summary"
+      )
+    );
+    console.log(_chalk2.default.gray("\u2500".repeat(80)));
+    for (const session of allSessions.slice(0, 20)) {
+      const id = session.sessionId.padEnd(24);
+      const created = new Date(session.createdAt).toLocaleString("en-US", {
+        month: "short",
+        day: "numeric",
+        hour: "numeric",
+        minute: "2-digit"
+      }).padEnd(19);
+      const messages = session.messageCount.toString().padEnd(11);
+      const summary = _optionalChain([session, 'access', _ => _.summary, 'optionalAccess', _2 => _2.slice, 'call', _3 => _3(0, 40)]) || _chalk2.default.gray("No summary");
+      console.log(` ${_chalk2.default.cyan(id)}${created}${messages}${summary}`);
+    }
+    if (allSessions.length > 20) {
+      console.log(_chalk2.default.gray(`
+... and ${allSessions.length - 20} more sessions`));
+    }
+    console.log(_chalk2.default.gray(`
+Use ${_chalk2.default.white("/resume <id>")} to continue a session`));
+    return null;
+  } catch (error) {
+    console.error(_chalk2.default.red(`Failed to list sessions: ${error.message}`));
+    return null;
+  }
+}
+
+
+
+
+exports.metadata = metadata; exports.sessions = sessions;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-WBDPILKI.cjs

@@ -0,0 +1,19 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/commands/quit.ts
+async function quit() {
+  return "/quit";
+}
+var metadata = {
+  command: "/quit",
+  description: "end the current Autohand session",
+  implemented: true
+};
+
+
+
+
+exports.quit = quit; exports.metadata = metadata;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-XT4OSHSB.cjs

@@ -0,0 +1,20 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/commands/model.ts
+async function model(ctx) {
+  await ctx.promptModelSelection();
+  return null;
+}
+var metadata = {
+  command: "/model",
+  description: "choose what model and reasoning effort to use",
+  implemented: true
+};
+
+
+
+
+exports.model = model; exports.metadata = metadata;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-Z4J4W6YQ.cjs

@@ -0,0 +1,339 @@
+"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(); } }// src/commands/formatters.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+
+// src/actions/formatters.ts
+var _child_process = require('child_process');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var EXTERNAL_FORMATTERS = {
+  prettier: {
+    name: "prettier",
+    command: "prettier",
+    extensions: [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".json", ".css", ".scss", ".less", ".html", ".md", ".yaml", ".yml", ".graphql"],
+    description: "Opinionated code formatter for JavaScript, TypeScript, CSS, and more",
+    checkCmd: ["prettier", "--version"]
+  },
+  black: {
+    name: "black",
+    command: "black",
+    extensions: [".py", ".pyi"],
+    description: "The uncompromising Python code formatter",
+    checkCmd: ["black", "--version"]
+  },
+  rustfmt: {
+    name: "rustfmt",
+    command: "rustfmt",
+    extensions: [".rs"],
+    description: "Format Rust code according to style guidelines",
+    checkCmd: ["rustfmt", "--version"]
+  },
+  gofmt: {
+    name: "gofmt",
+    command: "gofmt",
+    extensions: [".go"],
+    description: "Format Go source code",
+    checkCmd: ["gofmt", "-h"]
+  },
+  clangformat: {
+    name: "clang-format",
+    command: "clang-format",
+    extensions: [".c", ".cpp", ".h", ".hpp", ".cc", ".cxx"],
+    description: "Format C/C++ code",
+    checkCmd: ["clang-format", "--version"]
+  },
+  shfmt: {
+    name: "shfmt",
+    command: "shfmt",
+    extensions: [".sh", ".bash"],
+    description: "Format shell scripts",
+    checkCmd: ["shfmt", "--version"]
+  },
+  sqlformat: {
+    name: "sqlformat",
+    command: "sqlformat",
+    extensions: [".sql"],
+    description: "Format SQL files",
+    checkCmd: ["sqlformat", "--version"]
+  },
+  xmllint: {
+    name: "xmllint",
+    command: "xmllint",
+    extensions: [".xml", ".xsl", ".xslt"],
+    description: "Format XML files",
+    checkCmd: ["xmllint", "--version"]
+  }
+};
+async function isCommandAvailable(command) {
+  return new Promise((resolve) => {
+    const proc = _child_process.spawn.call(void 0, command, ["--version"], {
+      stdio: "ignore",
+      shell: process.platform === "win32"
+    });
+    proc.on("error", () => resolve(false));
+    proc.on("close", (code) => resolve(code === 0));
+    setTimeout(() => {
+      proc.kill();
+      resolve(false);
+    }, 2e3);
+  });
+}
+async function runExternalFormatter(command, args, input, cwd) {
+  return new Promise((resolve) => {
+    const proc = _child_process.spawn.call(void 0, command, args, {
+      cwd,
+      shell: process.platform === "win32",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("error", (err) => {
+      resolve({
+        success: false,
+        output: input,
+        error: `Failed to run ${command}: ${err.message}`
+      });
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve({ success: true, output: stdout || input });
+      } else {
+        resolve({
+          success: false,
+          output: input,
+          error: stderr || `${command} exited with code ${code}`
+        });
+      }
+    });
+    proc.stdin.write(input);
+    proc.stdin.end();
+    setTimeout(() => {
+      proc.kill();
+      resolve({
+        success: false,
+        output: input,
+        error: `${command} timed out after 30 seconds`
+      });
+    }, 3e4);
+  });
+}
+async function formatWithPrettier(contents, file, workspaceRoot) {
+  const ext = _path2.default.extname(file);
+  const parser = getPrettierParser(ext);
+  const result = await runExternalFormatter(
+    "prettier",
+    ["--stdin-filepath", file, ...parser ? ["--parser", parser] : []],
+    contents,
+    workspaceRoot
+  );
+  if (!result.success) {
+    throw new Error(result.error || "Prettier formatting failed");
+  }
+  return result.output;
+}
+function getPrettierParser(ext) {
+  const parserMap = {
+    ".js": "babel",
+    ".jsx": "babel",
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".mjs": "babel",
+    ".cjs": "babel",
+    ".json": "json",
+    ".css": "css",
+    ".scss": "scss",
+    ".less": "less",
+    ".html": "html",
+    ".md": "markdown",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".graphql": "graphql"
+  };
+  return parserMap[ext] || null;
+}
+async function formatWithBlack(contents, file, workspaceRoot) {
+  const result = await runExternalFormatter(
+    "black",
+    ["-", "--quiet"],
+    contents,
+    workspaceRoot
+  );
+  if (!result.success) {
+    throw new Error(result.error || "Black formatting failed");
+  }
+  return result.output;
+}
+async function formatWithRustfmt(contents, file, workspaceRoot) {
+  const result = await runExternalFormatter(
+    "rustfmt",
+    ["--emit", "stdout"],
+    contents,
+    workspaceRoot
+  );
+  if (!result.success) {
+    throw new Error(result.error || "rustfmt formatting failed");
+  }
+  return result.output;
+}
+async function formatWithGofmt(contents, file, workspaceRoot) {
+  const result = await runExternalFormatter(
+    "gofmt",
+    [],
+    contents,
+    workspaceRoot
+  );
+  if (!result.success) {
+    throw new Error(result.error || "gofmt formatting failed");
+  }
+  return result.output;
+}
+async function formatWithClangFormat(contents, file, workspaceRoot) {
+  const result = await runExternalFormatter(
+    "clang-format",
+    [`--assume-filename=${file}`],
+    contents,
+    workspaceRoot
+  );
+  if (!result.success) {
+    throw new Error(result.error || "clang-format formatting failed");
+  }
+  return result.output;
+}
+async function formatWithShfmt(contents, file, workspaceRoot) {
+  const result = await runExternalFormatter(
+    "shfmt",
+    ["-i", "2"],
+    // 2-space indent
+    contents,
+    workspaceRoot
+  );
+  if (!result.success) {
+    throw new Error(result.error || "shfmt formatting failed");
+  }
+  return result.output;
+}
+var builtinFormatters = {
+  json: async (contents) => {
+    const parsed = JSON.parse(contents);
+    return JSON.stringify(parsed, null, 2) + "\n";
+  },
+  trim: async (contents) => contents.trim() + "\n",
+  "normalize-newlines": async (contents) => {
+    return contents.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  },
+  "trailing-newline": async (contents) => {
+    return contents.endsWith("\n") ? contents : contents + "\n";
+  },
+  "remove-trailing-whitespace": async (contents) => {
+    return contents.split("\n").map((line) => line.trimEnd()).join("\n");
+  }
+};
+var externalFormatters = {
+  prettier: formatWithPrettier,
+  black: formatWithBlack,
+  rustfmt: formatWithRustfmt,
+  gofmt: formatWithGofmt,
+  "clang-format": formatWithClangFormat,
+  clangformat: formatWithClangFormat,
+  shfmt: formatWithShfmt
+};
+async function checkAvailableFormatters() {
+  const results = {};
+  for (const name of Object.keys(builtinFormatters)) {
+    results[name] = true;
+  }
+  const checks = Object.entries(EXTERNAL_FORMATTERS).map(async ([name, info]) => {
+    const available = await isCommandAvailable(info.command);
+    results[name] = available;
+  });
+  await Promise.all(checks);
+  return results;
+}
+async function listFormatters() {
+  const available = await checkAvailableFormatters();
+  const formatters = [
+    // Built-in formatters
+    { name: "json", command: "built-in", extensions: [".json"], description: "Format JSON with 2-space indent", checkCmd: [], installed: true },
+    { name: "trim", command: "built-in", extensions: ["*"], description: "Trim whitespace and ensure trailing newline", checkCmd: [], installed: true },
+    { name: "normalize-newlines", command: "built-in", extensions: ["*"], description: "Convert all line endings to LF", checkCmd: [], installed: true },
+    { name: "trailing-newline", command: "built-in", extensions: ["*"], description: "Ensure file ends with newline", checkCmd: [], installed: true },
+    { name: "remove-trailing-whitespace", command: "built-in", extensions: ["*"], description: "Remove trailing whitespace from lines", checkCmd: [], installed: true },
+    // External formatters
+    ...Object.entries(EXTERNAL_FORMATTERS).map(([name, info]) => ({
+      ...info,
+      installed: _nullishCoalesce(available[name], () => ( false))
+    }))
+  ];
+  return formatters;
+}
+async function applyFormatter(name, contents, file, workspaceRoot) {
+  const builtin = builtinFormatters[name];
+  if (builtin) {
+    return builtin(contents, file, workspaceRoot);
+  }
+  const external = externalFormatters[name];
+  if (external) {
+    return external(contents, file, workspaceRoot);
+  }
+  throw new Error(`Formatter "${name}" is not available. Run /formatters to see available formatters.`);
+}
+
+// src/commands/formatters.ts
+var metadata = {
+  command: "/formatters",
+  description: "List available code formatters",
+  implemented: true
+};
+async function execute() {
+  console.log();
+  console.log(_chalk2.default.cyan.bold("Available Code Formatters"));
+  console.log(_chalk2.default.gray("\u2500".repeat(60)));
+  console.log();
+  const formatters = await listFormatters();
+  const builtIn = formatters.filter((f) => f.command === "built-in");
+  const external = formatters.filter((f) => f.command !== "built-in");
+  console.log(_chalk2.default.yellow.bold("Built-in Formatters (always available):"));
+  console.log();
+  for (const f of builtIn) {
+    console.log(`  ${_chalk2.default.green("\u2713")} ${_chalk2.default.white.bold(f.name)}`);
+    console.log(`    ${_chalk2.default.gray(f.description)}`);
+    console.log(`    ${_chalk2.default.gray("Extensions:")} ${f.extensions.join(", ")}`);
+    console.log();
+  }
+  console.log(_chalk2.default.yellow.bold("External Formatters:"));
+  console.log();
+  for (const f of external) {
+    const status = f.installed ? _chalk2.default.green("\u2713 installed") : _chalk2.default.red("\u2717 not found");
+    console.log(`  ${f.installed ? _chalk2.default.green("\u2713") : _chalk2.default.red("\u2717")} ${_chalk2.default.white.bold(f.name)} ${_chalk2.default.gray(`(${f.command})`)} - ${status}`);
+    console.log(`    ${_chalk2.default.gray(f.description)}`);
+    console.log(`    ${_chalk2.default.gray("Extensions:")} ${f.extensions.join(", ")}`);
+    console.log();
+  }
+  console.log(_chalk2.default.gray("\u2500".repeat(60)));
+  console.log(_chalk2.default.gray("Usage: The agent can use format_file action with any installed formatter."));
+  console.log(_chalk2.default.gray("Install missing formatters via your package manager (npm, pip, cargo, etc.)"));
+  console.log();
+}
+
+
+
+
+
+exports.applyFormatter = applyFormatter; exports.metadata = metadata; exports.execute = execute;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Code Formatters
+ * Supports prettier, black, rustfmt, gofmt, and more
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */