autohand-cli 0.2.0

package/dist/chunk-TVWTD63Y.js

@@ -0,0 +1,50 @@
+// src/commands/help.ts
+import chalk from "chalk";
+import terminalLink from "terminal-link";
+async function help() {
+  console.log(chalk.cyan("\n\u{1F4DA} Available Commands:\n"));
+  const commands = [
+    { cmd: "/quit", desc: "Exit Autohand" },
+    { cmd: "/model", desc: "Configure providers (OpenRouter, Ollama, OpenAI, llama.cpp)" },
+    { cmd: "/session", desc: "Show current session info" },
+    { cmd: "/sessions", desc: "List sessions" },
+    { cmd: "/resume", desc: "Resume a session by id" },
+    { cmd: "/init", desc: "Create AGENTS.md file" },
+    { cmd: "/agents", desc: "List available sub-agents" },
+    { cmd: "/feedback", desc: "Send feedback with env details" },
+    { cmd: "/help / ?", desc: "Show this help" }
+  ];
+  commands.forEach(({ cmd, desc }) => {
+    console.log(`  ${chalk.yellow(cmd.padEnd(14))} ${chalk.gray(desc)}`);
+  });
+  console.log(chalk.cyan("\n\u{1F4A1} Tips:\n"));
+  console.log(chalk.gray("  \u2022 Type @ to mention files for the AI"));
+  console.log(chalk.gray("  \u2022 Use arrow keys to navigate file suggestions"));
+  console.log(chalk.gray("  \u2022 Press Tab to autocomplete file paths"));
+  console.log(chalk.gray("  \u2022 Press Esc to cancel current operation\n"));
+  const docLink = terminalLink("docs.autohand.ai", "https://docs.autohand.ai");
+  console.log(chalk.gray(`For more information, visit ${docLink}
+`));
+  return null;
+}
+var metadata = {
+  command: "/help",
+  description: "describe available slash commands and tips",
+  implemented: true
+};
+var aliasMetadata = {
+  command: "/?",
+  description: "alias for /help",
+  implemented: true
+};
+
+export {
+  help,
+  metadata,
+  aliasMetadata
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-UW2LYWIM.js

@@ -0,0 +1,131 @@
+import {
+  getAuthClient,
+  saveConfig
+} from "./chunk-A7HRTONQ.js";
+import {
+  AUTH_CONFIG
+} from "./chunk-2EPIFDFM.js";
+
+// src/commands/login.ts
+import chalk from "chalk";
+import enquirer from "enquirer";
+var metadata = {
+  command: "/login",
+  description: "sign in to your Autohand account",
+  implemented: true
+};
+async function openBrowser(url) {
+  try {
+    const open = await import("open").then((m) => m.default).catch(() => null);
+    if (open) {
+      await open(url);
+      return true;
+    }
+    const { exec } = await import("child_process");
+    const { promisify } = await import("util");
+    const execAsync = promisify(exec);
+    const platform = process.platform;
+    let command;
+    if (platform === "darwin") {
+      command = `open "${url}"`;
+    } else if (platform === "win32") {
+      command = `start "" "${url}"`;
+    } else {
+      command = `xdg-open "${url}"`;
+    }
+    await execAsync(command);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function login(ctx) {
+  const config = ctx.config;
+  if (config?.auth?.token && config?.auth?.user) {
+    const { continueLogin } = await enquirer.prompt({
+      type: "confirm",
+      name: "continueLogin",
+      message: `Already logged in as ${chalk.cyan(config.auth.user.email)}. Log in with a different account?`,
+      initial: false
+    });
+    if (!continueLogin) {
+      console.log(chalk.gray("Login cancelled."));
+      return null;
+    }
+  }
+  const authClient = getAuthClient();
+  console.log(chalk.gray("Initiating authentication..."));
+  const initResult = await authClient.initiateDeviceAuth();
+  if (!initResult.success || !initResult.deviceCode || !initResult.userCode) {
+    console.log(chalk.red(`Failed to start login: ${initResult.error || "Unknown error"}`));
+    return null;
+  }
+  console.log();
+  console.log(chalk.bold("To sign in, visit:"));
+  console.log(chalk.cyan.underline(initResult.verificationUriComplete || `${AUTH_CONFIG.authorizationUrl}?code=${initResult.userCode}`));
+  console.log();
+  console.log(chalk.gray("Or enter this code manually:"));
+  console.log(chalk.bold.yellow(`  ${initResult.userCode}`));
+  console.log();
+  const browserOpened = await openBrowser(
+    initResult.verificationUriComplete || `${AUTH_CONFIG.authorizationUrl}?code=${initResult.userCode}`
+  );
+  if (browserOpened) {
+    console.log(chalk.gray("Browser opened. Complete the login in your browser."));
+  } else {
+    console.log(chalk.yellow("Could not open browser automatically. Please visit the URL above."));
+  }
+  console.log();
+  console.log(chalk.gray("Waiting for authorization..."));
+  console.log(chalk.gray("(Press Ctrl+C to cancel)"));
+  const startTime = Date.now();
+  const timeout = AUTH_CONFIG.authTimeout;
+  const pollInterval = initResult.interval ? initResult.interval * 1e3 : AUTH_CONFIG.pollInterval;
+  let dots = 0;
+  const maxDots = 3;
+  while (Date.now() - startTime < timeout) {
+    process.stdout.write(`\r${chalk.gray("Waiting" + ".".repeat(dots + 1) + " ".repeat(maxDots - dots))}`);
+    dots = (dots + 1) % (maxDots + 1);
+    await sleep(pollInterval);
+    const pollResult = await authClient.pollDeviceAuth(initResult.deviceCode);
+    if (pollResult.status === "authorized" && pollResult.token && pollResult.user) {
+      process.stdout.write("\r" + " ".repeat(20) + "\r");
+      const expiresAt = new Date(Date.now() + AUTH_CONFIG.sessionExpiryDays * 24 * 60 * 60 * 1e3).toISOString();
+      const updatedConfig = {
+        ...config,
+        auth: {
+          token: pollResult.token,
+          user: pollResult.user,
+          expiresAt
+        }
+      };
+      await saveConfig(updatedConfig);
+      console.log();
+      console.log(chalk.green("Login successful!"));
+      console.log(chalk.cyan(`Welcome, ${pollResult.user.name || pollResult.user.email}!`));
+      console.log();
+      return null;
+    }
+    if (pollResult.status === "expired") {
+      process.stdout.write("\r" + " ".repeat(20) + "\r");
+      console.log(chalk.red("Authorization code expired. Please try again."));
+      return null;
+    }
+  }
+  process.stdout.write("\r" + " ".repeat(20) + "\r");
+  console.log(chalk.red("Authorization timed out. Please try again."));
+  return null;
+}
+
+export {
+  metadata,
+  login
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-VRI7EXV6.js

@@ -0,0 +1,20 @@
+// 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
+};
+
+export {
+  init,
+  metadata
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-XDVG3NM4.js

@@ -0,0 +1,339 @@
+// src/commands/formatters.ts
+import chalk from "chalk";
+
+// src/actions/formatters.ts
+import { spawn } from "child_process";
+import path from "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 = spawn(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 = spawn(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 = path.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: 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(chalk.cyan.bold("Available Code Formatters"));
+  console.log(chalk.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(chalk.yellow.bold("Built-in Formatters (always available):"));
+  console.log();
+  for (const f of builtIn) {
+    console.log(`  ${chalk.green("\u2713")} ${chalk.white.bold(f.name)}`);
+    console.log(`    ${chalk.gray(f.description)}`);
+    console.log(`    ${chalk.gray("Extensions:")} ${f.extensions.join(", ")}`);
+    console.log();
+  }
+  console.log(chalk.yellow.bold("External Formatters:"));
+  console.log();
+  for (const f of external) {
+    const status = f.installed ? chalk.green("\u2713 installed") : chalk.red("\u2717 not found");
+    console.log(`  ${f.installed ? chalk.green("\u2713") : chalk.red("\u2717")} ${chalk.white.bold(f.name)} ${chalk.gray(`(${f.command})`)} - ${status}`);
+    console.log(`    ${chalk.gray(f.description)}`);
+    console.log(`    ${chalk.gray("Extensions:")} ${f.extensions.join(", ")}`);
+    console.log();
+  }
+  console.log(chalk.gray("\u2500".repeat(60)));
+  console.log(chalk.gray("Usage: The agent can use format_file action with any installed formatter."));
+  console.log(chalk.gray("Install missing formatters via your package manager (npm, pip, cargo, etc.)"));
+  console.log();
+}
+
+export {
+  applyFormatter,
+  metadata,
+  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
+ */