autohand-cli 0.2.0

package/README.md

@@ -0,0 +1,134 @@
+# Autohand CLI
+
+[![Bun](https://img.shields.io/badge/Bun-%23c61f33?style=flat&logo=bun&logoColor=white)](https://bun.sh)
+
+Autohand implements a CLI-based AI coding assistant utilizing the ReAct (Reason + Act) reasoning pattern. The system processes requests through sequential phases: reasoning, tool invocation (file system, Git operations, shell commands), result interpretation, and JSON-formatted response generation. Implemented in TypeScript with Bun runtime for optimal performance.
+
+## Features
+
+- **ReAct Execution Model**: reason → tool calls → observation → final response
+- **Toolset**: 20+ operations including `read_file`, `write_file`, `git_status`, `run_command`, `search`, etc.
+- **Response Protocol**: Structured JSON `{"thought":"...","toolCalls":[...],"finalResponse":"..."}`
+- **Workspace Integration**: Operates within the current project directory with Git state awareness
+- **Runtime**: Bun-native with zero external dependencies, native TypeScript execution
+- **Safety Controls**: Destructive operations require explicit justification in reasoning trace
+
+## Local Development
+
+### Requirements
+- Bun ≥1.0 (`curl -fsSL https://bun.sh/install | bash`)
+
+### Installation
+```bash
+bun install
+```
+
+### Execution
+```bash
+# Development mode
+bun run dev
+
+# Production build and execution
+bun build
+./dist/cli.js
+
+# Global installation
+bun add -g .
+```
+
+## Configuration
+
+### LLM Provider Configuration
+
+Create a `.autohandrc.json` file in your project root or home directory:
+
+```json
+{
+  "openrouter": {
+    "apiKey": "your-api-key-here",
+    "model": "anthropic/claude-3.5-sonnet"
+  },
+  "workspace": {
+    "defaultRoot": ".",
+    "allowDangerousOps": false
+  },
+  "ui": {
+    "theme": "dark",
+    "autoConfirm": false,
+    "readFileCharLimit": 300
+  }
+}
+```
+
+### API Configuration (Telemetry & Feedback)
+
+For telemetry and feedback submission, create a `.env` file in the project root:
+
+```bash
+# Autohand API Configuration
+AUTOHAND_API_URL=https://api.autohand.ai
+AUTOHAND_SECRET=your-company-secret-here
+```
+
+**Note:** The Autohand feedback and telemetry API backend has been extracted to a separate repository:
+👉 https://github.com/autohandai/api
+
+The CLI includes client libraries with offline queueing, retry mechanisms, and privacy features. API authentication uses a compound identifier: `device_id.company_secret`.
+
+### UI Settings
+
+- **`readFileCharLimit`** (default: `300`): Maximum characters to display when reading files. Larger files will be truncated with a clear indicator.
+- **`theme`**: UI theme (`"dark"` | `"light"`)
+- **`autoConfirm`**: Skip confirmation prompts for destructive operations
+
+See `config.example.json` for a full example.
+
+## Deployment
+
+### Firecracker MicroVM
+
+Create `run-microvm.sh`:
+```bash
+#!/bin/bash
+firecracker --api-sock /tmp/fc.sock &
+
+cat > config.json <<EOF
+{
+  "boot-source": {
+    "kernel_image_path": "vmlinux.bin",
+    "boot_args": "console=ttyS0 reboot=k panic=1 pci=off"
+  },
+  "drives": [{
+    "drive_id": "rootfs",
+    "path_on_host": "rootfs.ext4",
+    "is_root_device": true,
+    "is_read_only": false
+  }],
+  "machine-config": { "vcpu_count": 2, "mem_size_mib": 1024 }
+}
+EOF
+
+curl --unix-socket /tmp/fc.sock -d @config.json http://localhost/actions
+
+# Within MicroVM: bun install && bun run dev
+```
+
+Execute: `chmod +x run-microvm.sh && ./run-microvm.sh`
+
+### Docker
+
+`Dockerfile`:
+```dockerfile
+FROM oven/bun:1
+WORKDIR /app
+COPY . .
+RUN bun install
+RUN bun build
+CMD ["./dist/cli.js"]
+```
+
+Build and run:
+```bash
+docker build -t autohand .
+docker run -it autohand
+```

package/dist/agents-RB34F4XE.js

@@ -0,0 +1,9 @@
+import {
+  handler,
+  metadata
+} from "./chunk-ALMJANSA.js";
+import "./chunk-2EPIFDFM.js";
+export {
+  handler,
+  metadata
+};

package/dist/agents-new-5I3B2W2I.js

@@ -0,0 +1,9 @@
+import {
+  createAgent,
+  metadata
+} from "./chunk-PX5AGAEX.js";
+import "./chunk-2EPIFDFM.js";
+export {
+  createAgent,
+  metadata
+};

package/dist/chunk-2EPIFDFM.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 getAuthBaseUrl = () => process["env"]["AUTOHAND_API_URL"] || "https://autohand.ai";
+var AUTH_CONFIG = {
+  get apiBaseUrl() {
+    return `${getAuthBaseUrl()}/api/auth`;
+  },
+  get authorizationUrl() {
+    return `${getAuthBaseUrl()}/cli-auth`;
+  },
+  pollInterval: 2e3,
+  authTimeout: 5 * 60 * 1e3,
+  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-2NUX2RAI.js

@@ -0,0 +1,145 @@
+// src/commands/lint.ts
+import chalk2 from "chalk";
+
+// src/actions/linters.ts
+import { spawn } from "child_process";
+import path from "path";
+import chalk from "chalk";
+var LINTERS = {
+  eslint: {
+    name: "eslint",
+    command: "eslint",
+    extensions: [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"],
+    description: "Pluggable JavaScript/TypeScript linter",
+    checkCmd: ["eslint", "--version"]
+  },
+  pylint: {
+    name: "pylint",
+    command: "pylint",
+    extensions: [".py"],
+    description: "Python static code analysis tool",
+    checkCmd: ["pylint", "--version"]
+  },
+  ruff: {
+    name: "ruff",
+    command: "ruff",
+    extensions: [".py"],
+    description: "Extremely fast Python linter (recommended)",
+    checkCmd: ["ruff", "--version"]
+  },
+  clippy: {
+    name: "clippy",
+    command: "cargo",
+    extensions: [".rs"],
+    description: "Rust linter with helpful suggestions",
+    checkCmd: ["cargo", "clippy", "--version"]
+  },
+  golangci: {
+    name: "golangci-lint",
+    command: "golangci-lint",
+    extensions: [".go"],
+    description: "Fast Go linter aggregator",
+    checkCmd: ["golangci-lint", "--version"]
+  },
+  shellcheck: {
+    name: "shellcheck",
+    command: "shellcheck",
+    extensions: [".sh", ".bash"],
+    description: "Shell script static analysis tool",
+    checkCmd: ["shellcheck", "--version"]
+  },
+  stylelint: {
+    name: "stylelint",
+    command: "stylelint",
+    extensions: [".css", ".scss", ".less"],
+    description: "CSS linter",
+    checkCmd: ["stylelint", "--version"]
+  },
+  htmlhint: {
+    name: "htmlhint",
+    command: "htmlhint",
+    extensions: [".html", ".htm"],
+    description: "HTML linter",
+    checkCmd: ["htmlhint", "--version"]
+  }
+};
+async function isCommandAvailable(command, args = ["--version"]) {
+  return new Promise((resolve) => {
+    const proc = spawn(command, args, {
+      stdio: "ignore",
+      shell: process.platform === "win32"
+    });
+    proc.on("error", () => resolve(false));
+    proc.on("close", (code) => resolve(code === 0));
+    setTimeout(() => {
+      proc.kill();
+      resolve(false);
+    }, 3e3);
+  });
+}
+async function checkAvailableLinters() {
+  const results = {};
+  const checks = Object.entries(LINTERS).map(async ([name, info]) => {
+    if (name === "clippy") {
+      results[name] = await isCommandAvailable("cargo", ["clippy", "--version"]);
+    } else {
+      results[name] = await isCommandAvailable(info.command);
+    }
+  });
+  await Promise.all(checks);
+  return results;
+}
+async function listLinters() {
+  const available = await checkAvailableLinters();
+  return Object.entries(LINTERS).map(([name, info]) => ({
+    ...info,
+    installed: available[name] ?? false
+  }));
+}
+
+// src/commands/lint.ts
+var metadata = {
+  command: "/lint",
+  description: "List available code linters",
+  implemented: true
+};
+async function execute() {
+  console.log();
+  console.log(chalk2.cyan.bold("Available Code Linters"));
+  console.log(chalk2.gray("\u2500".repeat(60)));
+  console.log();
+  const linters = await listLinters();
+  for (const linter of linters) {
+    const status = linter.installed ? chalk2.green("\u2713 installed") : chalk2.red("\u2717 not found");
+    console.log(`  ${linter.installed ? chalk2.green("\u2713") : chalk2.red("\u2717")} ${chalk2.white.bold(linter.name)} ${chalk2.gray(`(${linter.command})`)} - ${status}`);
+    console.log(`    ${chalk2.gray(linter.description)}`);
+    console.log(`    ${chalk2.gray("Extensions:")} ${linter.extensions.join(", ")}`);
+    console.log();
+  }
+  console.log(chalk2.gray("\u2500".repeat(60)));
+  console.log(chalk2.gray("Usage: The agent can use lint_file action to check code quality."));
+  console.log(chalk2.gray("Install missing linters via your package manager:"));
+  console.log(chalk2.gray("  npm: npm install -g eslint stylelint"));
+  console.log(chalk2.gray("  pip: pip install pylint ruff"));
+  console.log(chalk2.gray("  cargo: rustup component add clippy"));
+  console.log(chalk2.gray("  go: go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest"));
+  console.log();
+}
+
+export {
+  metadata,
+  execute
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Code Linters
+ * Supports eslint, pylint, clippy, golangci-lint, and more
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-2QAL3HH4.js

@@ -0,0 +1,79 @@
+import {
+  AUTOHAND_FILES
+} from "./chunk-2EPIFDFM.js";
+
+// src/commands/feedback.ts
+import fs from "fs-extra";
+import chalk from "chalk";
+import enquirer from "enquirer";
+var metadata = {
+  command: "/feedback",
+  description: "share feedback with environment details",
+  implemented: true
+};
+async function feedback(_ctx) {
+  const answer = await enquirer.prompt([
+    {
+      type: "input",
+      name: "feedback",
+      message: "What worked? What broke?"
+    }
+  ]);
+  if (!answer.feedback?.trim()) {
+    console.log(chalk.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: process.versions?.bun,
+      cwd: process.cwd(),
+      shell: process.env.SHELL
+    },
+    runtimeError: runtimeError ? formatError(runtimeError) : null
+  };
+  try {
+    const feedbackPath = AUTOHAND_FILES.feedbackLog;
+    await fs.ensureFile(feedbackPath);
+    await fs.appendFile(feedbackPath, JSON.stringify(payload) + "\n", "utf8");
+    console.log(chalk.green("Feedback recorded."));
+    console.log(chalk.gray(`Saved to ${feedbackPath}`));
+  } catch (error) {
+    console.error(chalk.red(`Failed to save feedback: ${error.message}`));
+  }
+  if (runtimeError) {
+    console.log(chalk.yellow("Detected a recent runtime error; included in feedback payload."));
+  }
+  return null;
+}
+function getLastRuntimeError() {
+  const globalAny = globalThis;
+  return 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) };
+}
+
+export {
+  metadata,
+  feedback
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */