autohand-cli 0.6.1 → 0.6.2

package/dist/chunk-Y7FSNXMR.js

@@ -0,0 +1,382 @@
+import {
+  AUTH_CONFIG,
+  AUTOHAND_FILES
+} from "./chunk-7FMMKTRG.js";
+
+// src/config.ts
+import fs from "fs-extra";
+import path from "path";
+import YAML from "yaml";
+var DEFAULT_CONFIG_PATH = AUTOHAND_FILES.configJson;
+var YAML_CONFIG_PATH = AUTOHAND_FILES.configYaml;
+var YML_CONFIG_PATH = AUTOHAND_FILES.configYml;
+var DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
+var DEFAULT_OLLAMA_URL = "http://localhost:11434";
+var DEFAULT_LLAMACPP_URL = "http://localhost:8080";
+var DEFAULT_OPENAI_URL = "https://api.openai.com/v1";
+async function detectConfigPath(customPath) {
+  if (customPath) {
+    return path.resolve(customPath);
+  }
+  const envPath = process.env.AUTOHAND_CONFIG;
+  if (envPath) {
+    return path.resolve(envPath);
+  }
+  if (await fs.pathExists(YAML_CONFIG_PATH)) {
+    return YAML_CONFIG_PATH;
+  }
+  if (await fs.pathExists(YML_CONFIG_PATH)) {
+    return YML_CONFIG_PATH;
+  }
+  return DEFAULT_CONFIG_PATH;
+}
+function isYamlFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return ext === ".yaml" || ext === ".yml";
+}
+async function parseConfigFile(configPath) {
+  const content = await fs.readFile(configPath, "utf8");
+  if (isYamlFile(configPath)) {
+    return YAML.parse(content);
+  }
+  return JSON.parse(content);
+}
+async function loadConfig(customPath) {
+  const configPath = await detectConfigPath(customPath);
+  await fs.ensureDir(path.dirname(configPath));
+  if (!await fs.pathExists(configPath)) {
+    const defaultConfig = {
+      provider: "openrouter",
+      openrouter: {
+        apiKey: "replace-me",
+        baseUrl: "https://openrouter.ai/api/v1",
+        model: "anthropic/claude-3.5-sonnet"
+      },
+      workspace: {
+        defaultRoot: process.cwd(),
+        allowDangerousOps: false
+      },
+      ui: {
+        theme: "dark",
+        autoConfirm: false
+      }
+    };
+    await fs.writeJson(configPath, defaultConfig, { spaces: 2 });
+    throw new Error(
+      `Created default config at ${configPath}. Please update it with your OpenRouter credentials before rerunning.`
+    );
+  }
+  let parsed;
+  try {
+    parsed = await parseConfigFile(configPath);
+  } catch (error) {
+    throw new Error(`Failed to parse config at ${configPath}: ${error.message}`);
+  }
+  const normalized = normalizeConfig(parsed);
+  const withEnv = mergeEnvVariables(normalized);
+  validateConfig(withEnv, configPath);
+  return { ...withEnv, configPath };
+}
+function mergeEnvVariables(config) {
+  return {
+    ...config,
+    api: {
+      baseUrl: process.env.AUTOHAND_API_URL || config.api?.baseUrl || "https://api.autohand.ai",
+      companySecret: process.env.AUTOHAND_SECRET || config.api?.companySecret || ""
+    }
+  };
+}
+function normalizeConfig(config) {
+  if (isModernConfig(config)) {
+    const provider = config.provider ?? "openrouter";
+    return { provider, ...config };
+  }
+  if (isLegacyConfig(config)) {
+    return {
+      provider: "openrouter",
+      openrouter: {
+        apiKey: config.api_key ?? "replace-me",
+        baseUrl: config.base_url ?? DEFAULT_BASE_URL,
+        model: config.model ?? "anthropic/claude-3.5-sonnet"
+      },
+      workspace: {
+        defaultRoot: process.cwd(),
+        allowDangerousOps: false
+      },
+      ui: {
+        autoConfirm: config.dry_run ?? false,
+        theme: "dark"
+      }
+    };
+  }
+  return config;
+}
+function isModernConfig(config) {
+  return typeof config.openrouter === "object" || typeof config.ollama === "object" || typeof config.llamacpp === "object" || typeof config.openai === "object";
+}
+function isLegacyConfig(config) {
+  return typeof config.api_key === "string";
+}
+function validateConfig(config, configPath) {
+  const provider = config.provider ?? "openrouter";
+  const providerConfig = getProviderConfig(config, provider);
+  if (config.workspace) {
+    if (config.workspace.defaultRoot && typeof config.workspace.defaultRoot !== "string") {
+      throw new Error(`workspace.defaultRoot must be a string in ${configPath}`);
+    }
+    if (config.workspace.allowDangerousOps !== void 0 && typeof config.workspace.allowDangerousOps !== "boolean") {
+      throw new Error(`workspace.allowDangerousOps must be boolean in ${configPath}`);
+    }
+  }
+  if (config.ui) {
+    if (config.ui.theme && config.ui.theme !== "dark" && config.ui.theme !== "light") {
+      throw new Error(`ui.theme must be 'dark' or 'light' in ${configPath}`);
+    }
+    if (config.ui.autoConfirm !== void 0 && typeof config.ui.autoConfirm !== "boolean") {
+      throw new Error(`ui.autoConfirm must be boolean in ${configPath}`);
+    }
+  }
+  if (config.externalAgents) {
+    if (config.externalAgents.enabled !== void 0 && typeof config.externalAgents.enabled !== "boolean") {
+      throw new Error(`externalAgents.enabled must be boolean in ${configPath}`);
+    }
+    if (config.externalAgents.paths !== void 0) {
+      if (!Array.isArray(config.externalAgents.paths)) {
+        throw new Error(`externalAgents.paths must be an array in ${configPath}`);
+      }
+      for (const p of config.externalAgents.paths) {
+        if (typeof p !== "string") {
+          throw new Error(`externalAgents.paths must contain only strings in ${configPath}`);
+        }
+      }
+    }
+  }
+}
+function resolveWorkspaceRoot(config, requestedPath) {
+  const candidate = requestedPath ?? process.cwd() ?? config.workspace?.defaultRoot;
+  return path.resolve(candidate);
+}
+function getProviderConfig(config, provider) {
+  const chosen = provider ?? config.provider ?? "openrouter";
+  const configByProvider = {
+    openrouter: config.openrouter,
+    ollama: config.ollama,
+    llamacpp: config.llamacpp,
+    openai: config.openai
+  };
+  const entry = configByProvider[chosen];
+  if (!entry) {
+    return null;
+  }
+  if (chosen === "openrouter") {
+    const { apiKey, model } = entry;
+    if (!apiKey || apiKey === "replace-me" || !model) {
+      return null;
+    }
+  } else {
+    if (!entry.model) {
+      return null;
+    }
+  }
+  return {
+    ...entry,
+    baseUrl: entry.baseUrl ?? defaultBaseUrlFor(chosen, entry.port)
+  };
+}
+function defaultBaseUrlFor(provider, port) {
+  if (provider === "openrouter") return DEFAULT_BASE_URL;
+  const p = port ? port.toString() : void 0;
+  switch (provider) {
+    case "ollama":
+      return p ? `http://localhost:${p}` : DEFAULT_OLLAMA_URL;
+    case "llamacpp":
+      return p ? `http://localhost:${p}` : DEFAULT_LLAMACPP_URL;
+    case "openai":
+      return DEFAULT_OPENAI_URL;
+    default:
+      return void 0;
+  }
+}
+async function saveConfig(config) {
+  const { configPath, ...data } = config;
+  if (isYamlFile(configPath)) {
+    const yamlContent = YAML.stringify(data, { indent: 2 });
+    await fs.writeFile(configPath, yamlContent, "utf8");
+  } else {
+    await fs.writeJson(configPath, data, { spaces: 2 });
+  }
+}
+
+// src/auth/AuthClient.ts
+var DEFAULT_TIMEOUT = 1e4;
+var AuthClient = class {
+  constructor(config = {}) {
+    this.baseUrl = config.baseUrl || AUTH_CONFIG.apiBaseUrl;
+    this.timeout = config.timeout || DEFAULT_TIMEOUT;
+  }
+  /**
+   * Initiate device authorization flow
+   * Returns device code and user code for display
+   */
+  async initiateDeviceAuth() {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}/cli/initiate`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ clientId: "autohand-cli" }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const data = await response.json();
+      if (!response.ok) {
+        return {
+          success: false,
+          error: data.error || data.message || `HTTP ${response.status}`
+        };
+      }
+      return {
+        success: true,
+        deviceCode: data.deviceCode,
+        userCode: data.userCode,
+        verificationUri: data.verificationUri,
+        verificationUriComplete: data.verificationUriComplete,
+        expiresIn: data.expiresIn,
+        interval: data.interval
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error.name === "AbortError") {
+        return { success: false, error: "Request timeout" };
+      }
+      return { success: false, error: error.message };
+    }
+  }
+  /**
+   * Poll for device authorization status
+   */
+  async pollDeviceAuth(deviceCode) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}/cli/poll`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ deviceCode }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const data = await response.json();
+      if (!response.ok && response.status !== 404) {
+        return {
+          success: false,
+          status: "pending",
+          error: data.error || data.message || `HTTP ${response.status}`
+        };
+      }
+      return {
+        success: data.success !== false,
+        status: data.status || "pending",
+        token: data.token,
+        user: data.user,
+        error: data.error
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error.name === "AbortError") {
+        return { success: false, status: "pending", error: "Request timeout" };
+      }
+      return { success: false, status: "pending", error: error.message };
+    }
+  }
+  /**
+   * Validate current session token
+   */
+  async validateSession(token) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}/me`, {
+        method: "GET",
+        headers: {
+          "Authorization": `Bearer ${token}`,
+          "Cookie": `auth_session=${token}`
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        return { authenticated: false };
+      }
+      const data = await response.json();
+      return {
+        authenticated: true,
+        user: data.user || data
+      };
+    } catch {
+      clearTimeout(timeoutId);
+      return { authenticated: false };
+    }
+  }
+  /**
+   * Logout and invalidate session
+   */
+  async logout(token) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}/logout`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${token}`,
+          "Cookie": `auth_session=${token}`
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return { success: response.ok };
+    } catch {
+      clearTimeout(timeoutId);
+      return { success: true };
+    }
+  }
+};
+var instance = null;
+function getAuthClient(config) {
+  if (!instance) {
+    instance = new AuthClient(config);
+  }
+  return instance;
+}
+
+export {
+  loadConfig,
+  resolveWorkspaceRoot,
+  getProviderConfig,
+  saveConfig,
+  getAuthClient
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Auth API Client for CLI authentication
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Auth module exports
+ */

package/dist/chunk-YPZMUIB5.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: "Choose AI model" },
+    { 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-ZMDUVLR4.js

@@ -0,0 +1,148 @@
+import {
+  AUTOHAND_PATHS
+} from "./chunk-RAL2W5UX.js";
+
+// src/commands/agents.ts
+import chalk from "chalk";
+
+// src/core/agents/AgentRegistry.ts
+import fs from "fs/promises";
+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.agentsDir = AUTOHAND_PATHS.agents;
+  }
+  static getInstance() {
+    if (!_AgentRegistry.instance) {
+      _AgentRegistry.instance = new _AgentRegistry();
+    }
+    return _AgentRegistry.instance;
+  }
+  /**
+   * Scans the agents directory and loads all valid agent configurations.
+   */
+  async loadAgents() {
+    this.agents.clear();
+    try {
+      await fs.mkdir(this.agentsDir, { recursive: true });
+      const files = await fs.readdir(this.agentsDir);
+      for (const file of files) {
+        const filePath = path.join(this.agentsDir, file);
+        if (file.endsWith(".json")) {
+          await this.loadJsonAgent(filePath);
+          continue;
+        }
+        if (file.endsWith(".md") || file.endsWith(".markdown")) {
+          await this.loadMarkdownAgent(filePath);
+        }
+      }
+    } catch (error) {
+      console.error(`Error loading agents from ${this.agentsDir}:`, error);
+    }
+  }
+  getAgent(name) {
+    return this.agents.get(name);
+  }
+  getAllAgents() {
+    return Array.from(this.agents.values());
+  }
+  getAgentsDirectory() {
+    return this.agentsDir;
+  }
+  async loadJsonAgent(filePath) {
+    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);
+      this.agents.set(name, { name, path: filePath, ...config });
+    } catch (error) {
+      console.warn(`Failed to load agent '${name}': ${error.message}`);
+    }
+  }
+  async loadMarkdownAgent(filePath) {
+    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,
+        description,
+        systemPrompt: content,
+        tools: [],
+        model: void 0
+      };
+      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
+ */