autohand-cli 0.6.0 → 0.6.2

package/dist/chunk-2FUWKZFN.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://autohand.ai/api/auth",
+  /** URL where users authorize CLI devices */
+  authorizationUrl: "https://autohand.ai/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-2HIILNYH.js

@@ -0,0 +1,197 @@
+import {
+  AUTOHAND_PATHS
+} from "./chunk-7FMMKTRG.js";
+
+// src/commands/agents.ts
+import chalk from "chalk";
+
+// src/core/agents/AgentRegistry.ts
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+import { z } from "zod";
+var AgentConfigSchema = z.object({
+  description: z.string(),
+  systemPrompt: z.string(),
+  tools: z.array(z.string()),
+  model: z.string().optional()
+});
+var AgentRegistry = class _AgentRegistry {
+  constructor() {
+    this.agents = /* @__PURE__ */ new Map();
+    this.externalPaths = [];
+    this.agentsDir = AUTOHAND_PATHS.agents;
+  }
+  static getInstance() {
+    if (!_AgentRegistry.instance) {
+      _AgentRegistry.instance = new _AgentRegistry();
+    }
+    return _AgentRegistry.instance;
+  }
+  /**
+   * Set external agent paths from config
+   * Supports tilde (~) expansion for home directory
+   */
+  setExternalPaths(paths) {
+    this.externalPaths = paths.map(
+      (p) => p.startsWith("~") ? path.join(os.homedir(), p.slice(1)) : p
+    );
+  }
+  /**
+   * Get configured external paths
+   */
+  getExternalPaths() {
+    return [...this.externalPaths];
+  }
+  /**
+   * Scans the agents directory and all external paths for agent configurations.
+   */
+  async loadAgents() {
+    this.agents.clear();
+    await this.loadAgentsFromDir(this.agentsDir, "user");
+    for (const extPath of this.externalPaths) {
+      await this.loadAgentsFromDir(extPath, "external");
+    }
+  }
+  /**
+   * Load agents from a specific directory
+   */
+  async loadAgentsFromDir(dir, source) {
+    try {
+      if (source === "user") {
+        await fs.mkdir(dir, { recursive: true });
+      }
+      const exists = await fs.access(dir).then(() => true).catch(() => false);
+      if (!exists) {
+        return;
+      }
+      const files = await fs.readdir(dir);
+      for (const file of files) {
+        const filePath = path.join(dir, file);
+        const stat = await fs.stat(filePath).catch(() => null);
+        if (!stat?.isFile()) {
+          continue;
+        }
+        if (file.endsWith(".json")) {
+          await this.loadJsonAgent(filePath, source);
+          continue;
+        }
+        if (file.endsWith(".md") || file.endsWith(".markdown")) {
+          await this.loadMarkdownAgent(filePath, source);
+        }
+      }
+    } catch (error) {
+      if (source === "user") {
+        console.error(`Error loading agents from ${dir}:`, error);
+      }
+    }
+  }
+  getAgent(name) {
+    return this.agents.get(name);
+  }
+  getAllAgents() {
+    return Array.from(this.agents.values());
+  }
+  getAgentsDirectory() {
+    return this.agentsDir;
+  }
+  /**
+   * Get agents filtered by source
+   */
+  getAgentsBySource(source) {
+    return this.getAllAgents().filter((a) => a.source === source);
+  }
+  async loadJsonAgent(filePath, source) {
+    const name = path.basename(filePath, ".json");
+    try {
+      const content = await fs.readFile(filePath, "utf-8");
+      const json = JSON.parse(content);
+      const config = AgentConfigSchema.parse(json);
+      if (!this.agents.has(name)) {
+        this.agents.set(name, { name, path: filePath, source, ...config });
+      }
+    } catch (error) {
+      console.warn(`Failed to load agent '${name}': ${error.message}`);
+    }
+  }
+  async loadMarkdownAgent(filePath, source) {
+    const name = path.basename(filePath, path.extname(filePath));
+    try {
+      const content = await fs.readFile(filePath, "utf-8");
+      const description = extractMarkdownTitle(content) || `Agent ${name}`;
+      const definition = {
+        name,
+        path: filePath,
+        source,
+        description,
+        systemPrompt: content,
+        tools: [],
+        model: void 0
+      };
+      if (!this.agents.has(name)) {
+        this.agents.set(name, definition);
+      }
+    } catch (error) {
+      console.warn(`Failed to load agent '${name}': ${error.message}`);
+    }
+  }
+};
+function extractMarkdownTitle(content) {
+  const lines = content.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("#")) {
+      return trimmed.replace(/^#+\s*/, "").trim() || null;
+    }
+    return trimmed;
+  }
+  return null;
+}
+
+// src/commands/agents.ts
+var metadata = {
+  command: "/agents",
+  description: "list available sub-agents (markdown or json)",
+  implemented: true,
+  prd: "prd/sub_agents_architecture.md"
+};
+async function handler() {
+  const registry = AgentRegistry.getInstance();
+  await registry.loadAgents();
+  const agents = registry.getAllAgents();
+  if (agents.length === 0) {
+    return `No agents found in ${chalk.cyan(registry.getAgentsDirectory())}.
+Create a markdown file (e.g., helper.md) there to define a new sub-agent.`;
+  }
+  let output = chalk.bold("Available Agents:\n\n");
+  for (const agent of agents) {
+    output += `${chalk.green("\u{1F916} " + agent.name)}
+`;
+    output += `  ${chalk.gray(agent.description)}
+`;
+    output += `  ${chalk.blue("Path:")} ${agent.path}
+`;
+    if (agent.model) {
+      output += `  ${chalk.yellow("Model:")} ${agent.model}
+`;
+    }
+    if (agent.tools?.length) {
+      output += `  ${chalk.blue("Tools:")} ${agent.tools.join(", ")}
+`;
+    }
+    output += "\n";
+  }
+  return output.trim();
+}
+
+export {
+  AgentRegistry,
+  metadata,
+  handler
+};
+/**
+ * @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
+ */

package/dist/chunk-3FRM7HJY.js

@@ -0,0 +1,57 @@
+import {
+  getAuthClient,
+  saveConfig
+} from "./chunk-HJYISR7Y.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
+ */

package/dist/chunk-4LDR3Y3A.js

@@ -0,0 +1,79 @@
+import {
+  AUTOHAND_FILES
+} from "./chunk-SN7D2PJO.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
+ */

package/dist/{chunk-6PYYLBNT.js → chunk-4LLTISFP.js}

@@ -5,7 +5,7 @@ import readline from "readline";
 // package.json
 var package_default = {
   name: "autohand-cli",
-  version: "0.6.0",
+  version: "0.1.0",
   description: "Autohand interactive coding agent CLI powered by LLMs.",
   type: "module",
   bin: {