autohand-cli 0.2.0

package/dist/chunk-A7HRTONQ.js

@@ -0,0 +1,382 @@
+import {
+  AUTH_CONFIG,
+  AUTOHAND_FILES
+} from "./chunk-2EPIFDFM.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-ALMJANSA.js

@@ -0,0 +1,197 @@
+import {
+  AUTOHAND_PATHS
+} from "./chunk-2EPIFDFM.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-GSOEIEOU.js

@@ -0,0 +1,19 @@
+// src/commands/quit.ts
+async function quit() {
+  return "/quit";
+}
+var metadata = {
+  command: "/quit",
+  description: "end the current Autohand session",
+  implemented: true
+};
+
+export {
+  quit,
+  metadata
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-I4HVBWYF.js

@@ -0,0 +1,55 @@
+// src/commands/undo.ts
+import chalk from "chalk";
+import { spawnSync } from "child_process";
+async function undo(ctx) {
+  console.log();
+  console.log(chalk.bold.yellow("Undoing changes..."));
+  const statusResult = spawnSync("git", ["status", "--porcelain"], {
+    cwd: ctx.workspaceRoot,
+    encoding: "utf8"
+  });
+  const hasGitChanges = statusResult.status === 0 && statusResult.stdout.trim().length > 0;
+  if (hasGitChanges) {
+    const checkoutResult = spawnSync("git", ["checkout", "--", "."], {
+      cwd: ctx.workspaceRoot,
+      encoding: "utf8"
+    });
+    if (checkoutResult.status === 0) {
+      console.log(chalk.green("  Reverted tracked file changes"));
+    }
+    const cleanResult = spawnSync("git", ["clean", "-fd"], {
+      cwd: ctx.workspaceRoot,
+      encoding: "utf8"
+    });
+    if (cleanResult.status === 0 && cleanResult.stdout.trim()) {
+      console.log(chalk.green("  Removed untracked files"));
+    }
+  } else {
+    console.log(chalk.gray("  No git changes to revert"));
+  }
+  try {
+    await ctx.undoFileMutation();
+    console.log(chalk.green("  Reverted last file mutation from undo stack"));
+  } catch {
+  }
+  ctx.removeLastTurn();
+  console.log(chalk.green("  Removed last conversation turn"));
+  console.log();
+  console.log(chalk.cyan("Undo complete. Ready for new instructions."));
+  return null;
+}
+var metadata = {
+  command: "/undo",
+  description: "revert git changes and remove last conversation turn",
+  implemented: true
+};
+
+export {
+  undo,
+  metadata
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-KZ7VMQTC.js

@@ -0,0 +1,20 @@
+// src/commands/model.ts
+async function model(ctx) {
+  await ctx.promptModelSelection();
+  return null;
+}
+var metadata = {
+  command: "/model",
+  description: "choose what model and reasoning effort to use",
+  implemented: true
+};
+
+export {
+  model,
+  metadata
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */