autohand-cli 0.8.2 → 0.9.0

package/dist/chunk-M4KNC5BQ.js

@@ -0,0 +1,78 @@
+import {
+  checkWorkspaceSafety
+} from "./chunk-PB7W7R72.js";
+import {
+  t
+} from "./chunk-CBFH2J3O.js";
+
+// src/commands/add-dir.ts
+import chalk from "chalk";
+import fs from "fs-extra";
+import path from "path";
+async function addDir(ctx, args) {
+  const dirPath = args.join(" ").trim();
+  if (!dirPath) {
+    console.log();
+    console.log(chalk.bold.cyan("Workspace Directories"));
+    console.log(chalk.gray("\u2500".repeat(50)));
+    console.log();
+    console.log(chalk.bold("Primary Workspace:"));
+    console.log(chalk.cyan(`  ${ctx.workspaceRoot}`));
+    console.log();
+    if (ctx.additionalDirs.length > 0) {
+      console.log(chalk.bold("Additional Directories:"));
+      ctx.additionalDirs.forEach((dir, index) => {
+        console.log(chalk.green(`  ${index + 1}. ${dir}`));
+      });
+    } else {
+      console.log(chalk.gray("No additional directories configured."));
+    }
+    console.log();
+    console.log(chalk.gray("Usage: /add-dir <path> to add a new directory"));
+    console.log();
+    return null;
+  }
+  const resolvedPath = path.resolve(dirPath);
+  if (!await fs.pathExists(resolvedPath)) {
+    console.log(chalk.red(t("commands.addDir.notFound", { path: dirPath })));
+    return null;
+  }
+  const stats = await fs.stat(resolvedPath);
+  if (!stats.isDirectory()) {
+    console.log(chalk.red(`Error: Path is not a directory: ${dirPath}`));
+    return null;
+  }
+  const safetyResult = checkWorkspaceSafety(resolvedPath);
+  if (!safetyResult.safe) {
+    console.log(chalk.red(`Error: Unsafe directory: ${dirPath}`));
+    console.log(chalk.yellow(`  ${safetyResult.reason}`));
+    return null;
+  }
+  if (resolvedPath === ctx.workspaceRoot) {
+    console.log(chalk.yellow(`Directory is already the primary workspace: ${resolvedPath}`));
+    return null;
+  }
+  if (ctx.additionalDirs.includes(resolvedPath)) {
+    console.log(chalk.yellow(t("commands.addDir.alreadyAdded", { path: resolvedPath })));
+    return null;
+  }
+  ctx.addAdditionalDir(resolvedPath);
+  console.log(chalk.green(t("commands.addDir.added", { path: resolvedPath })));
+  console.log(chalk.gray("You can now read, write, and modify files in this directory."));
+  return null;
+}
+var metadata = {
+  command: "/add-dir",
+  description: t("commands.addDir.description"),
+  implemented: true
+};
+
+export {
+  addDir,
+  metadata
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-MO4KP6XS.cjs

@@ -0,0 +1,229 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunk7LWQCE4Ycjs = require('./chunk-7LWQCE4Y.cjs');
+
+
+var _chunkREMGR23Vcjs = require('./chunk-REMGR23V.cjs');
+
+
+var _chunk46C73ZKKcjs = require('./chunk-46C73ZKK.cjs');
+
+// src/reporting/processErrorReporting.ts
+var DEFAULT_API_BASE_URL = "https://api.autohand.ai";
+var DEFAULT_REPORT_TIMEOUT_MS = 6500;
+var installedProcesses = /* @__PURE__ */ new WeakSet();
+var managerCache = /* @__PURE__ */ new Map();
+function getArgValue(argv, flag) {
+  if (!argv) {
+    return void 0;
+  }
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (token === flag) {
+      return argv[i + 1];
+    }
+    if (token.startsWith(`${flag}=`)) {
+      return token.slice(flag.length + 1);
+    }
+  }
+  return void 0;
+}
+function resolveConfigPath(processRef, explicitPath) {
+  return _nullishCoalesce(_nullishCoalesce(explicitPath, () => ( getArgValue(processRef.argv, "--config"))), () => ( processRef.env.AUTOHAND_CONFIG));
+}
+function detectClientName(processRef) {
+  const envClientName = processRef.env.AUTOHAND_CLIENT_NAME;
+  if (envClientName) {
+    return envClientName;
+  }
+  const mode = getArgValue(processRef.argv, "--mode");
+  if (mode === "acp" || mode === "rpc") {
+    return mode;
+  }
+  return "cli";
+}
+function getLogPrefix(processRef) {
+  return detectClientName(processRef) === "acp" ? "[ACP]" : "[DEBUG]";
+}
+function captureLastError(reason) {
+  globalThis.__autohandLastError = reason;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function buildFallbackConfig(configPath, processRef) {
+  return {
+    provider: "openrouter",
+    api: {
+      baseUrl: processRef.env.AUTOHAND_API_URL || DEFAULT_API_BASE_URL,
+      companySecret: processRef.env.AUTOHAND_SECRET || ""
+    },
+    autoReport: {
+      enabled: true
+    },
+    telemetry: {
+      enabled: false
+    },
+    configPath: _nullishCoalesce(configPath, () => ( "process-error-fallback")),
+    isNewConfig: false
+  };
+}
+async function getAutoReportManager(processRef, explicitConfigPath) {
+  const configPath = resolveConfigPath(processRef, explicitConfigPath);
+  const cacheKey = _nullishCoalesce(configPath, () => ( "__default__"));
+  const cached = managerCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const managerPromise = (async () => {
+    let config;
+    try {
+      config = await _chunk46C73ZKKcjs.loadConfig.call(void 0, configPath);
+    } catch (e) {
+      config = buildFallbackConfig(configPath, processRef);
+    }
+    return new (0, _chunk7LWQCE4Ycjs.AutoReportManager)(config, _chunkREMGR23Vcjs.package_default.version);
+  })();
+  managerCache.set(cacheKey, managerPromise);
+  return managerPromise;
+}
+function isIgnorableStdinReadError(err, _processRef) {
+  if (!err || typeof err !== "object") {
+    return false;
+  }
+  const maybeError = err;
+  return maybeError.code === "EIO" && maybeError.syscall === "read";
+}
+function isIgnorableFilesystemError(err) {
+  if (!err || typeof err !== "object") return false;
+  const maybeError = err;
+  if (maybeError.syscall !== "mkdir") return false;
+  return maybeError.code === "EACCES" || maybeError.code === "EEXIST";
+}
+function isIgnorableTerminalOrRuntimeError(err) {
+  if (!err || typeof err !== "object") return false;
+  const message = _nullishCoalesce(err.message, () => ( ""));
+  if (/setRawMode.*errno/i.test(message)) return true;
+  if (message === "Generator is executing") return true;
+  if (message.includes("node:sqlite")) return true;
+  return false;
+}
+function isIgnorableUnhandledRejection(reason, processRef) {
+  if (reason && typeof reason === "object" && reason.code === "ERR_USE_AFTER_CLOSE") {
+    return true;
+  }
+  if (isIgnorableStdinReadError(reason, processRef)) return true;
+  if (isIgnorableFilesystemError(reason)) return true;
+  if (isIgnorableTerminalOrRuntimeError(reason)) return true;
+  return false;
+}
+function toReportableError(reason) {
+  if (reason instanceof Error) {
+    return reason;
+  }
+  const fallbackName = "NonErrorProcessFault";
+  if (reason && typeof reason === "object") {
+    const maybeErrorLike = reason;
+    const message = typeof maybeErrorLike.message === "string" ? maybeErrorLike.message : safeSerialize(reason);
+    const error2 = new Error(message);
+    error2.name = typeof maybeErrorLike.name === "string" ? maybeErrorLike.name : fallbackName;
+    return error2;
+  }
+  const error = new Error(typeof reason === "string" ? reason : String(reason));
+  error.name = fallbackName;
+  return error;
+}
+function safeSerialize(value) {
+  try {
+    return JSON.stringify(value);
+  } catch (e2) {
+    return String(value);
+  }
+}
+function describeReasonType(reason) {
+  if (reason === null) {
+    return "null";
+  }
+  if (Array.isArray(reason)) {
+    return "array";
+  }
+  return typeof reason;
+}
+async function reportProcessError(reason, options) {
+  const processRef = _nullishCoalesce(options.processRef, () => ( process));
+  if (options.handler === "unhandledRejection" && isIgnorableUnhandledRejection(reason, processRef)) {
+    return;
+  }
+  if (options.handler === "uncaughtException" && (isIgnorableStdinReadError(reason, processRef) || isIgnorableTerminalOrRuntimeError(reason))) {
+    return;
+  }
+  captureLastError(reason);
+  const error = toReportableError(reason);
+  const manager = await getAutoReportManager(processRef, options.configPath);
+  const reportPromise = manager.reportError(error, {
+    context: {
+      source: "process",
+      handler: options.handler,
+      clientName: detectClientName(processRef),
+      fatal: options.handler === "uncaughtException",
+      rawType: describeReasonType(reason),
+      ..._nullishCoalesce(options.extraContext, () => ( {}))
+    }
+  });
+  await Promise.race([
+    reportPromise,
+    sleep(_nullishCoalesce(options.reportTimeoutMs, () => ( DEFAULT_REPORT_TIMEOUT_MS)))
+  ]);
+}
+function installProcessErrorHandlers(options = {}) {
+  const processRef = _nullishCoalesce(options.processRef, () => ( process));
+  if (installedProcesses.has(processRef)) {
+    return;
+  }
+  installedProcesses.add(processRef);
+  const logError = _nullishCoalesce(options.logError, () => ( console.error.bind(console)));
+  const exit = _nullishCoalesce(options.exit, () => ( ((code) => {
+    processRef.exit(code);
+  })));
+  processRef.on("uncaughtException", (error) => {
+    if (isIgnorableStdinReadError(error, processRef)) {
+      return;
+    }
+    if (isIgnorableTerminalOrRuntimeError(error)) {
+      return;
+    }
+    captureLastError(error);
+    logError(`${getLogPrefix(processRef)} Uncaught Exception:`, error);
+    void (async () => {
+      await reportProcessError(error, {
+        handler: "uncaughtException",
+        processRef,
+        configPath: options.configPath,
+        reportTimeoutMs: options.reportTimeoutMs
+      });
+      exit(1);
+    })();
+  });
+  processRef.on("unhandledRejection", (reason, promise) => {
+    if (isIgnorableUnhandledRejection(reason, processRef)) {
+      return;
+    }
+    captureLastError(reason);
+    logError(`${getLogPrefix(processRef)} Unhandled Rejection at:`, promise, "reason:", reason);
+    void reportProcessError(reason, {
+      handler: "unhandledRejection",
+      processRef,
+      configPath: options.configPath,
+      reportTimeoutMs: options.reportTimeoutMs
+    });
+  });
+}
+
+
+
+exports.installProcessErrorHandlers = installProcessErrorHandlers;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-BVKXEQVG.cjs → chunk-MOJ7ADW4.cjs}

@@ -1,6 +1,6 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
 
-var _chunkSEKD5FH3cjs = require('./chunk-SEKD5FH3.cjs');
+var _chunkE26KKI46cjs = require('./chunk-E26KKI46.cjs');
 
 // src/core/agents/AgentRegistry.ts
 var _promises = require('fs/promises'); var _promises2 = _interopRequireDefault(_promises);
@@ -49,11 +49,13 @@ function parseMarkdownAgent(content) {
     model: meta.model
   };
 }
-var AgentRegistry = class _AgentRegistry {
-  constructor() {
-    this.agents = /* @__PURE__ */ new Map();
-    this.externalPaths = [];
-    this.agentsDir = _chunkSEKD5FH3cjs.AUTOHAND_PATHS.agents;
+var AgentRegistry = (_class = class _AgentRegistry {
+  
+  __init() {this.agents = /* @__PURE__ */ new Map()}
+  
+  __init2() {this.externalPaths = []}
+  constructor() {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+    this.agentsDir = _chunkE26KKI46cjs.AUTOHAND_PATHS.agents;
   }
   static getInstance() {
     if (!_AgentRegistry.instance) {
@@ -70,6 +72,16 @@ var AgentRegistry = class _AgentRegistry {
       (p) => p.startsWith("~") ? _path2.default.join(_os2.default.homedir(), p.slice(1)) : p
     );
   }
+  /**
+   * Apply external agent settings from the loaded Autohand config.
+   */
+  configureExternalAgents(config) {
+    if (_optionalChain([config, 'optionalAccess', _ => _.enabled]) !== true) {
+      this.setExternalPaths([]);
+      return;
+    }
+    this.setExternalPaths(_nullishCoalesce(config.paths, () => ( [])));
+  }
   /**
    * Get configured external paths
    */
@@ -103,7 +115,7 @@ var AgentRegistry = class _AgentRegistry {
       for (const file of files) {
         const filePath = _path2.default.join(dir, file);
         const stat = await _promises2.default.stat(filePath).catch(() => null);
-        if (!_optionalChain([stat, 'optionalAccess', _ => _.isFile, 'call', _2 => _2()])) {
+        if (!_optionalChain([stat, 'optionalAccess', _2 => _2.isFile, 'call', _3 => _3()])) {
           continue;
         }
         if (file.endsWith(".json")) {
@@ -159,7 +171,7 @@ var AgentRegistry = class _AgentRegistry {
         source,
         description: parsed.description || `Agent ${name}`,
         systemPrompt: parsed.systemPrompt,
-        tools: parsed.tools,
+        tools: parsed.tools.length > 0 ? parsed.tools : ["*"],
         model: parsed.model
       };
       if (!this.agents.has(name)) {
@@ -178,7 +190,7 @@ var AgentRegistry = class _AgentRegistry {
     const builtinDir = _path2.default.join(_path2.default.dirname(new URL(import.meta.url).pathname), "../../agents/builtin");
     await this.loadAgentsFromDir(builtinDir, "builtin");
   }
-};
+}, _class);