autohand-cli 0.8.3 → 0.9.1

package/dist/{chunk-BVKXEQVG.cjs → chunk-JV5HVCHU.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 _chunkKASXKDF2cjs = require('./chunk-KASXKDF2.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 = _chunkKASXKDF2cjs.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);
 
 
 

package/dist/chunk-KA2U6MY2.js

@@ -0,0 +1,388 @@
+import {
+  resolveRipgrepCommand
+} from "./chunk-UOQECODR.js";
+
+// src/startup/checks.ts
+import { spawn } from "child_process";
+import { constants as fsConstants } from "fs";
+import os from "os";
+import chalk from "chalk";
+import fs from "fs-extra";
+var GIT_COMMAND_TIMEOUT_MS = 5e3;
+var GIT_INIT_TIMEOUT_MS = 15e3;
+var toolCheckResultsPromise;
+function getCurrentBunVersion() {
+  return process.versions.bun;
+}
+var REQUIRED_TOOLS = [
+  {
+    name: "git",
+    command: "git",
+    versionFlag: "--version",
+    required: true,
+    description: "Version control (required for file tracking, undo, and git operations)",
+    installHints: {
+      darwin: "brew install git",
+      linux: "sudo apt install git  # or: sudo dnf install git",
+      win32: "winget install Git.Git  # or download from https://git-scm.com"
+    }
+  },
+  {
+    name: "ripgrep",
+    command: "rg",
+    versionFlag: "--version",
+    required: false,
+    description: "Fast code search (recommended for better search performance)",
+    installHints: {
+      darwin: "brew install ripgrep",
+      linux: "sudo apt install ripgrep  # or: cargo install ripgrep",
+      win32: "winget install BurntSushi.ripgrep  # or: scoop install ripgrep"
+    }
+  }
+];
+var OPTIONAL_TOOLS = [
+  {
+    name: "node",
+    command: "node",
+    versionFlag: "--version",
+    required: false,
+    description: "Node.js runtime (for npm/yarn package management)",
+    installHints: {
+      darwin: "brew install node  # or: nvm install node",
+      linux: "sudo apt install nodejs  # or: nvm install node",
+      win32: "winget install OpenJS.NodeJS  # or download from https://nodejs.org"
+    },
+    minVersion: "18.0.0"
+  },
+  {
+    name: "bun",
+    command: "bun",
+    versionFlag: "--version",
+    required: false,
+    description: "Bun runtime (fast JavaScript/TypeScript runtime)",
+    installHints: {
+      darwin: "curl -fsSL https://bun.sh/install | bash",
+      linux: "curl -fsSL https://bun.sh/install | bash",
+      win32: 'powershell -c "irm bun.sh/install.ps1 | iex"'
+    }
+  }
+];
+function checkTool(tool) {
+  const platform = os.platform();
+  const installHint = tool.installHints[platform] || tool.installHints.linux;
+  const command = tool.command === "rg" ? resolveRipgrepCommand() : tool.command;
+  const currentBunVersion = tool.command === "bun" ? getCurrentBunVersion() : void 0;
+  if (tool.command === "bun") {
+    return Promise.resolve({
+      name: tool.name,
+      installed: currentBunVersion !== void 0,
+      version: currentBunVersion,
+      required: tool.required,
+      description: tool.description,
+      installHint: currentBunVersion === void 0 ? installHint : void 0
+    });
+  }
+  return new Promise((resolve) => {
+    try {
+      const proc = spawn(command, [tool.versionFlag], {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      const timeout = setTimeout(() => {
+        proc.kill();
+        resolve({
+          name: tool.name,
+          installed: false,
+          required: tool.required,
+          description: tool.description,
+          installHint
+        });
+      }, 5e3);
+      proc.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      proc.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      proc.on("close", (code) => {
+        clearTimeout(timeout);
+        if (code === 0) {
+          const output = (stdout || stderr).trim();
+          const versionMatch = output.match(/(\d+\.\d+(\.\d+)?)/);
+          const version = versionMatch ? versionMatch[1] : "unknown";
+          resolve({
+            name: tool.name,
+            installed: true,
+            version,
+            required: tool.required,
+            description: tool.description
+          });
+        } else {
+          resolve({
+            name: tool.name,
+            installed: false,
+            required: tool.required,
+            description: tool.description,
+            installHint
+          });
+        }
+      });
+      proc.on("error", () => {
+        clearTimeout(timeout);
+        resolve({
+          name: tool.name,
+          installed: false,
+          required: tool.required,
+          description: tool.description,
+          installHint
+        });
+      });
+    } catch {
+      resolve({
+        name: tool.name,
+        installed: false,
+        required: tool.required,
+        description: tool.description,
+        installHint
+      });
+    }
+  });
+}
+function checkStartupTools() {
+  toolCheckResultsPromise ??= Promise.all(
+    [...REQUIRED_TOOLS, ...OPTIONAL_TOOLS].map((tool) => checkTool(tool))
+  );
+  return toolCheckResultsPromise;
+}
+async function checkWorkspaceWritable(workspaceRoot) {
+  try {
+    const testFile = `${workspaceRoot}/.autohand-write-test-${Date.now()}`;
+    await fs.writeFile(testFile, "test");
+    await fs.remove(testFile);
+    return { writable: true };
+  } catch (error) {
+    return {
+      writable: false,
+      error: `Cannot write to workspace: ${error.message}`
+    };
+  }
+}
+async function validateWorkspacePath(workspaceRoot) {
+  try {
+    if (!await fs.pathExists(workspaceRoot)) {
+      return {
+        valid: false,
+        error: `Workspace path does not exist: ${workspaceRoot}`
+      };
+    }
+    const stats = await fs.stat(workspaceRoot);
+    if (!stats.isDirectory()) {
+      return {
+        valid: false,
+        error: `Workspace path is not a directory: ${workspaceRoot}`
+      };
+    }
+    await fs.access(workspaceRoot, fsConstants.R_OK | fsConstants.W_OK);
+    return { valid: true };
+  } catch (error) {
+    return {
+      valid: false,
+      error: `Cannot access workspace: ${error.message}`
+    };
+  }
+}
+function isEmptyDirectory(dir) {
+  try {
+    const entries = fs.readdirSync(dir);
+    const significantEntries = entries.filter((e) => !e.startsWith(".") || e === ".git");
+    return significantEntries.length === 0;
+  } catch {
+    return false;
+  }
+}
+function runGitCommand(args, cwd, timeoutMs = GIT_COMMAND_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    try {
+      const proc = spawn("git", args, { cwd, stdio: ["pipe", "pipe", "pipe"] });
+      let stdout = "";
+      const timeout = setTimeout(() => {
+        proc.kill();
+        resolve(void 0);
+      }, timeoutMs);
+      proc.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      proc.on("close", (code) => {
+        clearTimeout(timeout);
+        resolve(code === 0 ? stdout.trim() : void 0);
+      });
+      proc.on("error", () => {
+        clearTimeout(timeout);
+        resolve(void 0);
+      });
+    } catch {
+      resolve(void 0);
+    }
+  });
+}
+async function getGitBranch(workspaceRoot) {
+  const headBranch = readGitHeadBranch(workspaceRoot);
+  if (headBranch) return headBranch;
+  const branch = await runGitCommand(["rev-parse", "--abbrev-ref", "HEAD"], workspaceRoot);
+  if (branch) return branch;
+  return runGitCommand(["symbolic-ref", "--short", "HEAD"], workspaceRoot);
+}
+function readGitHeadBranch(workspaceRoot) {
+  try {
+    const head = fs.readFileSync(`${workspaceRoot}/.git/HEAD`, "utf8").trim();
+    const refPrefix = "ref: refs/heads/";
+    if (head.startsWith(refPrefix)) {
+      const branch = head.slice(refPrefix.length).trim();
+      return branch || void 0;
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+async function checkGitRepo(workspaceRoot) {
+  const gitDirExists = fs.existsSync(`${workspaceRoot}/.git`);
+  if (gitDirExists) {
+    if (!fs.existsSync(`${workspaceRoot}/.git/HEAD`)) {
+      return { isGitRepo: true };
+    }
+    const branch = await getGitBranch(workspaceRoot);
+    return {
+      isGitRepo: true,
+      branch
+    };
+  }
+  if (isEmptyDirectory(workspaceRoot)) {
+    const initResult = await runGitCommand(["init"], workspaceRoot, GIT_INIT_TIMEOUT_MS);
+    if (initResult !== void 0 || fs.existsSync(`${workspaceRoot}/.git/HEAD`)) {
+      if (os.platform() === "darwin") {
+        try {
+          const gitignorePath = `${workspaceRoot}/.gitignore`;
+          if (!fs.existsSync(gitignorePath)) {
+            fs.writeFileSync(gitignorePath, ".DS_Store\n");
+          }
+        } catch {
+        }
+      }
+      const branch = await getGitBranch(workspaceRoot) || "main";
+      return {
+        isGitRepo: true,
+        branch,
+        initialized: true
+      };
+    }
+  }
+  return { isGitRepo: false };
+}
+function getPackageManagerHint() {
+  const platform = os.platform();
+  switch (platform) {
+    case "darwin":
+      return "Homebrew (brew)";
+    case "linux":
+      return "apt, dnf, or your distro package manager";
+    case "win32":
+      return "winget, scoop, or chocolatey";
+    default:
+      return "your system package manager";
+  }
+}
+async function runStartupChecks(workspaceRoot) {
+  const warnings = [];
+  const [toolResults, workspaceCheck, gitCheck] = await Promise.all([
+    checkStartupTools(),
+    checkWorkspaceWritable(workspaceRoot),
+    checkGitRepo(workspaceRoot)
+  ]);
+  for (const result of toolResults) {
+    if (!result.installed && result.required) {
+      warnings.push(`Required tool '${result.name}' is not installed`);
+    }
+  }
+  if (!workspaceCheck.writable) {
+    warnings.push(workspaceCheck.error || "Workspace is not writable");
+  }
+  const allRequiredMet = toolResults.filter((r) => r.required).every((r) => r.installed);
+  return {
+    tools: toolResults,
+    workspace: {
+      path: workspaceRoot,
+      writable: workspaceCheck.writable,
+      isGitRepo: gitCheck.isGitRepo,
+      branch: gitCheck.branch,
+      initialized: gitCheck.initialized,
+      error: workspaceCheck.error
+    },
+    allRequiredMet,
+    warnings
+  };
+}
+function printStartupCheckResults(results, verbose = false) {
+  const missingRequired = results.tools.filter((t) => t.required && !t.installed);
+  const missingOptional = results.tools.filter((t) => !t.required && !t.installed);
+  if (results.workspace.initialized) {
+    console.log(chalk.green("\u2713 Initialized git repository"));
+    console.log();
+  }
+  if (missingRequired.length === 0 && !verbose) {
+    return;
+  }
+  console.log();
+  if (missingRequired.length > 0) {
+    console.log(chalk.red.bold("\u26A0 Missing required tools:"));
+    console.log();
+    for (const tool of missingRequired) {
+      console.log(chalk.red(`  \u2717 ${tool.name}`));
+      console.log(chalk.gray(`    ${tool.description}`));
+      console.log(chalk.cyan(`    Install: ${tool.installHint}`));
+      console.log();
+    }
+  }
+  if (missingOptional.length > 0 && verbose) {
+    console.log(chalk.yellow("Optional tools not installed:"));
+    for (const tool of missingOptional) {
+      console.log(chalk.yellow(`  \u25CB ${tool.name}`) + chalk.gray(` - ${tool.description}`));
+      console.log(chalk.gray(`    Install: ${tool.installHint}`));
+    }
+    console.log();
+  }
+  if (!results.workspace.writable) {
+    console.log(chalk.red(`\u26A0 Workspace issue: ${results.workspace.error}`));
+    console.log();
+  }
+  if (verbose) {
+    const installed = results.tools.filter((t) => t.installed);
+    if (installed.length > 0) {
+      console.log(chalk.green("Installed tools:"));
+      for (const tool of installed) {
+        const version = tool.version ? chalk.gray(` (${tool.version})`) : "";
+        console.log(chalk.green(`  \u2713 ${tool.name}${version}`));
+      }
+      console.log();
+    }
+  }
+  if (!results.allRequiredMet) {
+    console.log(chalk.red.bold("Some required tools are missing. Autohand may not work correctly."));
+    console.log(chalk.gray(`Use ${getPackageManagerHint()} to install them.`));
+    console.log();
+  }
+}
+
+export {
+  validateWorkspacePath,
+  runStartupChecks,
+  printStartupCheckResults
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Startup checks - validates required tools and environment
+ */

package/dist/{chunk-SEKD5FH3.cjs → chunk-KASXKDF2.cjs}

@@ -3,7 +3,7 @@ var _os = require('os'); var _os2 = _interopRequireDefault(_os);
 var _path = require('path'); var _path2 = _interopRequireDefault(_path);
 var AUTOHAND_HOME = process.env.AUTOHAND_HOME || _path2.default.join(_os2.default.homedir(), ".autohand");
 var AUTOHAND_PATHS = {
-  /** Configuration files (config.json, config.yaml, config.yml) */
+  /** Configuration files (config.toml, config.yaml, config.yml, config.json) */
   config: AUTOHAND_HOME,
   /** Session data storage */
   sessions: _path2.default.join(AUTOHAND_HOME, "sessions"),
@@ -33,6 +33,7 @@ var AUTOHAND_PATHS = {
 var AUTOHAND_FILES = {
   /** Main config file */
   configJson: _path2.default.join(AUTOHAND_HOME, "config.json"),
+  configToml: _path2.default.join(AUTOHAND_HOME, "config.toml"),
   configYaml: _path2.default.join(AUTOHAND_HOME, "config.yaml"),
   configYml: _path2.default.join(AUTOHAND_HOME, "config.yml"),
   /** Device ID for telemetry */
@@ -44,7 +45,9 @@ var AUTOHAND_FILES = {
   /** Telemetry queue */
   telemetryQueue: _path2.default.join(AUTOHAND_PATHS.telemetry, "queue.json"),
   /** Session sync queue */
-  sessionSyncQueue: _path2.default.join(AUTOHAND_PATHS.telemetry, "session-sync-queue.json")
+  sessionSyncQueue: _path2.default.join(AUTOHAND_PATHS.telemetry, "session-sync-queue.json"),
+  /** Last successful remote feature flag evaluation */
+  featureFlagsCache: _path2.default.join(AUTOHAND_HOME, "feature-flags.json")
 };
 var PROJECT_DIR_NAME = ".autohand";
 var getAuthBaseUrl = () => process["env"]["AUTOHAND_API_URL"] || "https://autohand.ai";
@@ -57,7 +60,9 @@ var AUTH_CONFIG = {
   },
   pollInterval: 2e3,
   authTimeout: 5 * 60 * 1e3,
-  sessionExpiryDays: 30
+  sessionExpiryDays: 30,
+  /** Idle timeout in ms before forcing logout (30 minutes) */
+  idleTimeoutMs: 30 * 60 * 1e3
 };
 var SYNC_CONFIG = {
   /** Default sync interval in ms (5 minutes) */