autohand-cli 0.6.0 → 0.6.2

package/dist/chunk-CD7GNBIE.js

@@ -0,0 +1,288 @@
+// src/commands/status.ts
+import chalk from "chalk";
+import readline from "readline";
+
+// package.json
+var package_default = {
+  name: "autohand-cli",
+  version: "0.5.1",
+  description: "Autohand interactive coding agent CLI powered by LLMs.",
+  type: "module",
+  bin: {
+    autohand: "dist/index.js"
+  },
+  main: "dist/index.js",
+  files: [
+    "dist"
+  ],
+  scripts: {
+    go: 'bun run build && ./install-local.sh && echo "COMPLETED"',
+    build: "tsup src/index.ts --format esm,cjs --dts",
+    dev: "tsx src/index.ts",
+    typecheck: "tsc --noEmit",
+    lint: "eslint .",
+    test: "vitest run",
+    start: "node dist/index.js",
+    "compile:macos-arm64": "bun build ./src/index.ts --compile --target=bun-darwin-arm64 --outfile ./binaries/autohand-macos-arm64",
+    "compile:macos-x64": "bun build ./src/index.ts --compile --target=bun-darwin-x64 --outfile ./binaries/autohand-macos-x64",
+    "compile:linux-x64": "bun build ./src/index.ts --compile --target=bun-linux-x64 --outfile ./binaries/autohand-linux-x64",
+    "compile:linux-arm64": "bun build ./src/index.ts --compile --target=bun-linux-arm64 --outfile ./binaries/autohand-linux-arm64",
+    "compile:windows-x64": "bun build ./src/index.ts --compile --target=bun-windows-x64 --outfile ./binaries/autohand-windows-x64.exe",
+    "compile:all": "bun run compile:macos-arm64 && bun run compile:macos-x64 && bun run compile:linux-x64 && bun run compile:linux-arm64 && bun run compile:windows-x64",
+    link: "bun link"
+  },
+  keywords: [
+    "cli",
+    "llm",
+    "agent",
+    "autohand"
+  ],
+  engines: {
+    node: ">=18.17.0"
+  },
+  dependencies: {
+    chalk: "^5.6.2",
+    commander: "^14.0.2",
+    diff: "^8.0.2",
+    dotenv: "^17.2.3",
+    enquirer: "^2.4.1",
+    "fs-extra": "^11.3.2",
+    ignore: "^5.3.1",
+    ink: "^4.4.1",
+    open: "^10.1.0",
+    ora: "^9.0.0",
+    react: "^18.2.0",
+    "terminal-link": "^3.0.0",
+    yaml: "^2.8.2",
+    zod: "^4.1.12"
+  },
+  devDependencies: {
+    "@types/diff": "^8.0.0",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^24.10.1",
+    "@types/react": "^18.3.3",
+    "@types/terminal-link": "^1.2.0",
+    "@typescript-eslint/eslint-plugin": "^8.48.1",
+    "@typescript-eslint/parser": "^8.48.1",
+    eslint: "^9.39.1",
+    "react-devtools-core": "^7.0.1",
+    tsup: "^8.5.1",
+    tsx: "^4.20.6",
+    typescript: "^5.9.3",
+    vitest: "^1.6.0"
+  }
+};
+
+// src/commands/status.ts
+var metadata = {
+  command: "/status",
+  description: "Show Autohand status including version, model, API connectivity, and usage",
+  implemented: true
+};
+async function status(ctx) {
+  const data = await gatherStatusData(ctx);
+  await renderStatusUI(data);
+  return null;
+}
+async function gatherStatusData(ctx) {
+  const currentSession = ctx.sessionManager.getCurrentSession();
+  const allSessions = await ctx.sessionManager.listSessions();
+  let apiConnected = false;
+  try {
+    apiConnected = await ctx.llm.isAvailable();
+  } catch {
+    apiConnected = false;
+  }
+  return {
+    version: package_default.version,
+    sessionId: currentSession?.metadata.sessionId ?? null,
+    cwd: ctx.workspaceRoot,
+    provider: ctx.provider ?? "openrouter",
+    model: ctx.model,
+    apiConnected,
+    sessionsCount: allSessions.length,
+    contextPercentLeft: ctx.getContextPercentLeft?.() ?? 100,
+    totalTokensUsed: ctx.getTotalTokensUsed?.() ?? 0,
+    config: ctx.config
+  };
+}
+function renderStatusUI(data) {
+  return new Promise((resolve) => {
+    const tabs = ["Status", "Config", "Usage"];
+    let currentTab = 0;
+    const input = process.stdin;
+    const isTTY = input.isTTY;
+    const wasRaw = input.isRaw;
+    const wasPaused = typeof input.isPaused === "function" ? input.isPaused() : false;
+    if (wasPaused && typeof input.resume === "function") {
+      input.resume();
+    }
+    if (isTTY) {
+      readline.emitKeypressEvents(input);
+      if (!wasRaw && typeof input.setRawMode === "function") {
+        input.setRawMode(true);
+      }
+      if (typeof input.setEncoding === "function") {
+        input.setEncoding("utf8");
+      }
+    }
+    const render = () => {
+      process.stdout.write("\x1B[2J\x1B[H");
+      renderTabHeader(tabs, currentTab);
+      renderTabContent(tabs[currentTab], data);
+      console.log(chalk.gray("\nEsc to exit"));
+    };
+    let buffer = "";
+    const handler = (chunk) => {
+      buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      const processNext = () => {
+        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);
+            handleSequence(seq);
+            return true;
+          }
+          buffer = buffer.slice(1);
+          handleSequence("\x1B");
+          return true;
+        }
+        buffer = buffer.slice(1);
+        handleSequence(first);
+        return true;
+      };
+      while (processNext()) {
+      }
+    };
+    const handleSequence = (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;
+        default:
+          return;
+      }
+    };
+    const cleanup = () => {
+      input.off("data", handler);
+      if (isTTY && !wasRaw && typeof input.setRawMode === "function") {
+        input.setRawMode(false);
+      }
+      if (wasPaused && typeof input.pause === "function") {
+        input.pause();
+      }
+      process.stdout.write("\x1B[2J\x1B[H");
+    };
+    input.on("data", handler);
+    render();
+  });
+}
+function renderTabHeader(tabs, currentIndex) {
+  const header = tabs.map((tab, i) => {
+    return i === currentIndex ? chalk.bgWhite.black(` ${tab} `) : chalk.gray(` ${tab} `);
+  }).join("  ");
+  console.log(`Settings: ${header}  ${chalk.gray("(tab to cycle)")}
+`);
+}
+function renderTabContent(tab, data) {
+  switch (tab) {
+    case "Status":
+      renderStatusTab(data);
+      break;
+    case "Config":
+      renderConfigTab(data);
+      break;
+    case "Usage":
+      renderUsageTab(data);
+      break;
+  }
+}
+function renderStatusTab(data) {
+  console.log(chalk.bold("Version:"), data.version);
+  console.log(chalk.bold("Session ID:"), data.sessionId ?? chalk.gray("none"));
+  console.log(chalk.bold("cwd:"), data.cwd);
+  console.log(chalk.bold("Provider:"), data.provider);
+  console.log(chalk.bold("Model:"), data.model);
+  console.log();
+  console.log(
+    chalk.bold("API Status:"),
+    data.apiConnected ? chalk.green("Connected") : chalk.red("Disconnected")
+  );
+  console.log(chalk.bold("Sessions:"), `${data.sessionsCount} total`);
+  console.log(chalk.bold("Memory:"), "user (~/.autohand/memory/), project (.autohand/memory/)");
+}
+function renderConfigTab(data) {
+  const config = data.config;
+  console.log(chalk.bold("Autohand preferences\n"));
+  const settings = [
+    ["Theme", config?.ui?.theme ?? "dark"],
+    ["Auto-confirm", config?.ui?.autoConfirm ? "true" : "false"],
+    ["Show thinking", config?.ui?.showThinking !== false ? "true" : "false"],
+    ["Show completion notification", config?.ui?.showCompletionNotification !== false ? "true" : "false"],
+    ["Permission mode", config?.permissions?.mode ?? "interactive"],
+    ["Telemetry", config?.telemetry?.enabled !== false ? "true" : "false"],
+    ["Network retries", String(config?.network?.maxRetries ?? 3)],
+    ["Network timeout", `${config?.network?.timeout ?? 3e4}ms`]
+  ];
+  for (const [name, value] of settings) {
+    console.log(`  ${chalk.cyan(name.padEnd(30))} ${value}`);
+  }
+}
+function renderUsageTab(data) {
+  const contextUsed = 100 - data.contextPercentLeft;
+  console.log(chalk.bold("Current session\n"));
+  renderProgressBar("Context used", contextUsed, 100);
+  console.log();
+  console.log(chalk.bold("Tokens used:"), formatTokens(data.totalTokensUsed));
+}
+function renderProgressBar(label, value, max) {
+  const width = 30;
+  const filled = Math.round(value / max * width);
+  const empty = width - filled;
+  const bar = chalk.cyan("\u2588".repeat(filled)) + chalk.gray("\u2591".repeat(empty));
+  const percent = Math.round(value / max * 100);
+  console.log(label);
+  console.log(`${bar}  ${percent}% used`);
+}
+function formatTokens(tokens) {
+  if (tokens >= 1e3) {
+    return `${(tokens / 1e3).toFixed(1)}k tokens`;
+  }
+  return `${tokens} tokens`;
+}
+
+export {
+  package_default,
+  metadata,
+  status
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-CV3LEQRD.js

@@ -0,0 +1,57 @@
+// src/commands/memory.ts
+import chalk from "chalk";
+async function memory(ctx) {
+  const { project, user } = await ctx.memoryManager.listAll();
+  console.log();
+  console.log(chalk.bold.cyan("Stored Memories"));
+  console.log(chalk.gray("\u2500".repeat(50)));
+  if (project.length === 0 && user.length === 0) {
+    console.log(chalk.gray("No memories stored yet."));
+    console.log();
+    console.log(chalk.gray("Tip: Type # followed by text to store a memory."));
+    console.log(chalk.gray("Example: # Always use TypeScript strict mode"));
+    return null;
+  }
+  if (project.length > 0) {
+    console.log();
+    console.log(chalk.bold.yellow("Project Memories") + chalk.gray(" (.autohand/memory/)"));
+    console.log();
+    for (const entry of project) {
+      const date = new Date(entry.updatedAt).toLocaleDateString();
+      const tags = entry.tags?.length ? chalk.cyan(` [${entry.tags.join(", ")}]`) : "";
+      console.log(chalk.white(`  ${entry.content}`));
+      console.log(chalk.gray(`    ID: ${entry.id} | Updated: ${date}${tags}`));
+      console.log();
+    }
+  }
+  if (user.length > 0) {
+    console.log();
+    console.log(chalk.bold.magenta("User Memories") + chalk.gray(" (~/.autohand-cli/memory/)"));
+    console.log();
+    for (const entry of user) {
+      const date = new Date(entry.updatedAt).toLocaleDateString();
+      const tags = entry.tags?.length ? chalk.cyan(` [${entry.tags.join(", ")}]`) : "";
+      console.log(chalk.white(`  ${entry.content}`));
+      console.log(chalk.gray(`    ID: ${entry.id} | Updated: ${date}${tags}`));
+      console.log();
+    }
+  }
+  console.log(chalk.gray("\u2500".repeat(50)));
+  console.log(chalk.gray(`Total: ${project.length} project, ${user.length} user memories`));
+  return null;
+}
+var metadata = {
+  command: "/memory",
+  description: "view stored project and user memories",
+  implemented: true
+};
+
+export {
+  memory,
+  metadata
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-DAHMHLM6.js

@@ -0,0 +1,102 @@
+// src/commands/agents-new.ts
+import os from "os";
+import path from "path";
+import fs from "fs-extra";
+import chalk from "chalk";
+import enquirer from "enquirer";
+var metadata = {
+  command: "/agents new",
+  description: "create a new sub-agent from a description",
+  implemented: true,
+  prd: "prd/sub_agents_architecture.md"
+};
+async function createAgent(ctx) {
+  const answers = await enquirer.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "Agent name (e.g., Researcher, QA Tester)",
+      validate: (val) => typeof val === "string" && val.trim() ? true : "Name is required"
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Briefly describe what the agent should do"
+    }
+  ]);
+  const name = answers.name.trim();
+  const description = answers.description.trim();
+  if (!name) {
+    console.log(chalk.gray("Canceled: no name provided."));
+    return null;
+  }
+  const filename = await ensureUniqueFilename(name);
+  const filePath = path.join(getAgentsDir(), filename);
+  const prompt = buildPrompt(name, description);
+  let content;
+  try {
+    const completion = await ctx.llm.complete({
+      messages: [
+        {
+          role: "system",
+          content: "You generate concise markdown definitions for sub-agents. Output only markdown with no code fences. Keep it short but complete."
+        },
+        { role: "user", content: prompt }
+      ],
+      maxTokens: 600
+    });
+    content = completion.content.trim();
+  } catch (error) {
+    console.error(chalk.red(`Failed to generate agent: ${error.message}`));
+    return null;
+  }
+  try {
+    await fs.ensureDir(getAgentsDir());
+    await fs.writeFile(filePath, content + "\n", "utf8");
+    console.log(chalk.green(`Saved new agent to ${filePath}`));
+  } catch (error) {
+    console.error(chalk.red(`Failed to save agent: ${error.message}`));
+    return null;
+  }
+  return null;
+}
+function buildPrompt(name, description) {
+  return [
+    `Create a sub-agent markdown file for "${name}".`,
+    description ? `Agent description: ${description}` : "",
+    "Structure it as:",
+    "# <Name>",
+    "## Purpose",
+    "## Operating Mode (bullet list)",
+    "## Tools (bullet list; mention existing CLI tools and constraints briefly)",
+    "## Output Contract (what to return to main agent)",
+    "Be concise, 120-160 words total."
+  ].filter(Boolean).join("\n");
+}
+function getAgentsDir() {
+  return path.join(os.homedir(), ".autohand-cli", "agents");
+}
+function slugify(input) {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
+}
+async function ensureUniqueFilename(name) {
+  const base = slugify(name);
+  const dir = getAgentsDir();
+  let candidate = `${base}.md`;
+  let counter = 1;
+  while (await fs.pathExists(path.join(dir, candidate))) {
+    candidate = `${base}-${counter}.md`;
+    counter += 1;
+  }
+  return candidate;
+}
+
+export {
+  metadata,
+  createAgent
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-DAMLAWGE.js

@@ -0,0 +1,68 @@
+// src/constants.ts
+import os from "os";
+import path from "path";
+var AUTOHAND_HOME = process.env.AUTOHAND_HOME || path.join(os.homedir(), ".autohand");
+var AUTOHAND_PATHS = {
+  /** Configuration files (config.json, config.yaml, config.yml) */
+  config: AUTOHAND_HOME,
+  /** Session data storage */
+  sessions: path.join(AUTOHAND_HOME, "sessions"),
+  /** Project knowledge base */
+  projects: path.join(AUTOHAND_HOME, "projects"),
+  /** User-level memory */
+  memory: path.join(AUTOHAND_HOME, "memory"),
+  /** Feedback state and responses */
+  feedback: path.join(AUTOHAND_HOME, "feedback"),
+  /** Telemetry data */
+  telemetry: path.join(AUTOHAND_HOME, "telemetry"),
+  /** Custom commands */
+  commands: path.join(AUTOHAND_HOME, "commands"),
+  /** Agent definitions */
+  agents: path.join(AUTOHAND_HOME, "agents"),
+  /** Custom tools */
+  tools: path.join(AUTOHAND_HOME, "tools")
+};
+var AUTOHAND_FILES = {
+  /** Main config file */
+  configJson: path.join(AUTOHAND_HOME, "config.json"),
+  configYaml: path.join(AUTOHAND_HOME, "config.yaml"),
+  configYml: path.join(AUTOHAND_HOME, "config.yml"),
+  /** Device ID for telemetry */
+  deviceId: path.join(AUTOHAND_HOME, "device-id"),
+  /** Error log */
+  errorLog: path.join(AUTOHAND_HOME, "error.log"),
+  /** Feedback log */
+  feedbackLog: path.join(AUTOHAND_HOME, "feedback.log"),
+  /** Telemetry queue */
+  telemetryQueue: path.join(AUTOHAND_PATHS.telemetry, "queue.json"),
+  /** Session sync queue */
+  sessionSyncQueue: path.join(AUTOHAND_PATHS.telemetry, "session-sync-queue.json")
+};
+var PROJECT_DIR_NAME = ".autohand";
+var AUTH_CONFIG = {
+  /** Base URL for the authentication API */
+  apiBaseUrl: "https://e3fe87a1.autohand-web.pages.dev/api/auth",
+  /** URL where users authorize CLI devices */
+  authorizationUrl: "https://e3fe87a1.autohand-web.pages.dev/cli-auth",
+  /** Polling interval in milliseconds */
+  pollInterval: 2e3,
+  /** Timeout for device authorization in milliseconds (5 minutes) */
+  authTimeout: 5 * 60 * 1e3,
+  /** CLI session expiry in days */
+  sessionExpiryDays: 30
+};
+
+export {
+  AUTOHAND_HOME,
+  AUTOHAND_PATHS,
+  AUTOHAND_FILES,
+  PROJECT_DIR_NAME,
+  AUTH_CONFIG
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Centralized constants for Autohand CLI
+ */

package/dist/chunk-F4YPGOQJ.js

@@ -0,0 +1,105 @@
+import {
+  AUTOHAND_PATHS
+} from "./chunk-IAOMCEYU.js";
+
+// src/commands/agents-new.ts
+import path from "path";
+import fs from "fs-extra";
+import chalk from "chalk";
+import enquirer from "enquirer";
+var metadata = {
+  command: "/agents new",
+  description: "create a new sub-agent from a description",
+  implemented: true,
+  prd: "prd/sub_agents_architecture.md"
+};
+async function createAgent(ctx) {
+  const answers = await enquirer.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "Agent name (e.g., Researcher, QA Tester)",
+      validate: (val) => typeof val === "string" && val.trim() ? true : "Name is required"
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Briefly describe what the agent should do"
+    }
+  ]);
+  const name = answers.name.trim();
+  const description = answers.description.trim();
+  if (!name) {
+    console.log(chalk.gray("Canceled: no name provided."));
+    return null;
+  }
+  const filename = await ensureUniqueFilename(name);
+  const filePath = path.join(getAgentsDir(), filename);
+  const prompt = buildPrompt(name, description);
+  let content;
+  try {
+    const completion = await ctx.llm.complete({
+      messages: [
+        {
+          role: "system",
+          content: "You generate concise markdown definitions for sub-agents. Output only markdown with no code fences. Keep it short but complete."
+        },
+        { role: "user", content: prompt }
+      ],
+      maxTokens: 600
+    });
+    content = completion.content.trim();
+  } catch (error) {
+    console.error(chalk.red(`Failed to generate agent: ${error.message}`));
+    return null;
+  }
+  try {
+    await fs.ensureDir(getAgentsDir());
+    await fs.writeFile(filePath, content + "\n", "utf8");
+    console.log(chalk.green(`Saved new agent to ${filePath}`));
+  } catch (error) {
+    console.error(chalk.red(`Failed to save agent: ${error.message}`));
+    return null;
+  }
+  return null;
+}
+function buildPrompt(name, description) {
+  return [
+    `Create a sub-agent markdown file for "${name}".`,
+    description ? `Agent description: ${description}` : "",
+    "Structure it as:",
+    "# <Name>",
+    "## Purpose",
+    "## Operating Mode (bullet list)",
+    "## Tools (bullet list; mention existing CLI tools and constraints briefly)",
+    "## Output Contract (what to return to main agent)",
+    "Be concise, 120-160 words total."
+  ].filter(Boolean).join("\n");
+}
+function getAgentsDir() {
+  return AUTOHAND_PATHS.agents;
+}
+function slugify(input) {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
+}
+async function ensureUniqueFilename(name) {
+  const base = slugify(name);
+  const dir = getAgentsDir();
+  let candidate = `${base}.md`;
+  let counter = 1;
+  while (await fs.pathExists(path.join(dir, candidate))) {
+    candidate = `${base}-${counter}.md`;
+    counter += 1;
+  }
+  return candidate;
+}
+
+export {
+  metadata,
+  createAgent
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-FQDXFNOI.js

@@ -0,0 +1,57 @@
+import {
+  getAuthClient,
+  saveConfig
+} from "./chunk-JZQKOM7X.js";
+
+// src/commands/logout.ts
+import chalk from "chalk";
+import enquirer from "enquirer";
+var metadata = {
+  command: "/logout",
+  description: "sign out of your Autohand account",
+  implemented: true
+};
+async function logout(ctx) {
+  const config = ctx.config;
+  if (!config?.auth?.token) {
+    console.log(chalk.yellow("You are not currently logged in."));
+    console.log(chalk.gray("Use /login to sign in to your Autohand account."));
+    return null;
+  }
+  const userName = config.auth.user?.name || config.auth.user?.email || "user";
+  const { confirm } = await enquirer.prompt({
+    type: "confirm",
+    name: "confirm",
+    message: `Log out from ${chalk.cyan(userName)}?`,
+    initial: true
+  });
+  if (!confirm) {
+    console.log(chalk.gray("Logout cancelled."));
+    return null;
+  }
+  const authClient = getAuthClient();
+  try {
+    await authClient.logout(config.auth.token);
+  } catch {
+  }
+  const updatedConfig = {
+    ...config,
+    auth: void 0
+  };
+  await saveConfig(updatedConfig);
+  console.log();
+  console.log(chalk.green("Successfully logged out."));
+  console.log(chalk.gray("Your local session has been cleared."));
+  console.log();
+  return null;
+}
+
+export {
+  metadata,
+  logout
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */