autohand-cli 0.8.3 → 0.9.1

package/dist/chunk-QLZOMZO5.cjs

@@ -0,0 +1,388 @@
+"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; }
+
+var _chunkXF2WIKHRcjs = require('./chunk-XF2WIKHR.cjs');
+
+// src/startup/checks.ts
+var _child_process = require('child_process');
+var _fs = require('fs');
+var _os = require('os'); var _os2 = _interopRequireDefault(_os);
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+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 = _os2.default.platform();
+  const installHint = tool.installHints[platform] || tool.installHints.linux;
+  const command = tool.command === "rg" ? _chunkXF2WIKHRcjs.resolveRipgrepCommand.call(void 0, ) : 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 = _child_process.spawn.call(void 0, 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);
+      _optionalChain([proc, 'access', _ => _.stdout, 'optionalAccess', _2 => _2.on, 'call', _3 => _3("data", (chunk) => {
+        stdout += chunk.toString();
+      })]);
+      _optionalChain([proc, 'access', _4 => _4.stderr, 'optionalAccess', _5 => _5.on, 'call', _6 => _6("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 (e2) {
+      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 _fsextra2.default.writeFile(testFile, "test");
+    await _fsextra2.default.remove(testFile);
+    return { writable: true };
+  } catch (error) {
+    return {
+      writable: false,
+      error: `Cannot write to workspace: ${error.message}`
+    };
+  }
+}
+async function validateWorkspacePath(workspaceRoot) {
+  try {
+    if (!await _fsextra2.default.pathExists(workspaceRoot)) {
+      return {
+        valid: false,
+        error: `Workspace path does not exist: ${workspaceRoot}`
+      };
+    }
+    const stats = await _fsextra2.default.stat(workspaceRoot);
+    if (!stats.isDirectory()) {
+      return {
+        valid: false,
+        error: `Workspace path is not a directory: ${workspaceRoot}`
+      };
+    }
+    await _fsextra2.default.access(workspaceRoot, _fs.constants.R_OK | _fs.constants.W_OK);
+    return { valid: true };
+  } catch (error) {
+    return {
+      valid: false,
+      error: `Cannot access workspace: ${error.message}`
+    };
+  }
+}
+function isEmptyDirectory(dir) {
+  try {
+    const entries = _fsextra2.default.readdirSync(dir);
+    const significantEntries = entries.filter((e) => !e.startsWith(".") || e === ".git");
+    return significantEntries.length === 0;
+  } catch (e3) {
+    return false;
+  }
+}
+function runGitCommand(args, cwd, timeoutMs = GIT_COMMAND_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    try {
+      const proc = _child_process.spawn.call(void 0, "git", args, { cwd, stdio: ["pipe", "pipe", "pipe"] });
+      let stdout = "";
+      const timeout = setTimeout(() => {
+        proc.kill();
+        resolve(void 0);
+      }, timeoutMs);
+      _optionalChain([proc, 'access', _7 => _7.stdout, 'optionalAccess', _8 => _8.on, 'call', _9 => _9("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 (e4) {
+      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 = _fsextra2.default.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 (e5) {
+    return void 0;
+  }
+  return void 0;
+}
+async function checkGitRepo(workspaceRoot) {
+  const gitDirExists = _fsextra2.default.existsSync(`${workspaceRoot}/.git`);
+  if (gitDirExists) {
+    if (!_fsextra2.default.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 || _fsextra2.default.existsSync(`${workspaceRoot}/.git/HEAD`)) {
+      if (_os2.default.platform() === "darwin") {
+        try {
+          const gitignorePath = `${workspaceRoot}/.gitignore`;
+          if (!_fsextra2.default.existsSync(gitignorePath)) {
+            _fsextra2.default.writeFileSync(gitignorePath, ".DS_Store\n");
+          }
+        } catch (e6) {
+        }
+      }
+      const branch = await getGitBranch(workspaceRoot) || "main";
+      return {
+        isGitRepo: true,
+        branch,
+        initialized: true
+      };
+    }
+  }
+  return { isGitRepo: false };
+}
+function getPackageManagerHint() {
+  const platform = _os2.default.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(_chalk2.default.green("\u2713 Initialized git repository"));
+    console.log();
+  }
+  if (missingRequired.length === 0 && !verbose) {
+    return;
+  }
+  console.log();
+  if (missingRequired.length > 0) {
+    console.log(_chalk2.default.red.bold("\u26A0 Missing required tools:"));
+    console.log();
+    for (const tool of missingRequired) {
+      console.log(_chalk2.default.red(`  \u2717 ${tool.name}`));
+      console.log(_chalk2.default.gray(`    ${tool.description}`));
+      console.log(_chalk2.default.cyan(`    Install: ${tool.installHint}`));
+      console.log();
+    }
+  }
+  if (missingOptional.length > 0 && verbose) {
+    console.log(_chalk2.default.yellow("Optional tools not installed:"));
+    for (const tool of missingOptional) {
+      console.log(_chalk2.default.yellow(`  \u25CB ${tool.name}`) + _chalk2.default.gray(` - ${tool.description}`));
+      console.log(_chalk2.default.gray(`    Install: ${tool.installHint}`));
+    }
+    console.log();
+  }
+  if (!results.workspace.writable) {
+    console.log(_chalk2.default.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(_chalk2.default.green("Installed tools:"));
+      for (const tool of installed) {
+        const version = tool.version ? _chalk2.default.gray(` (${tool.version})`) : "";
+        console.log(_chalk2.default.green(`  \u2713 ${tool.name}${version}`));
+      }
+      console.log();
+    }
+  }
+  if (!results.allRequiredMet) {
+    console.log(_chalk2.default.red.bold("Some required tools are missing. Autohand may not work correctly."));
+    console.log(_chalk2.default.gray(`Use ${getPackageManagerHint()} to install them.`));
+    console.log();
+  }
+}
+
+
+
+
+
+exports.validateWorkspacePath = validateWorkspacePath; exports.runStartupChecks = runStartupChecks; exports.printStartupCheckResults = printStartupCheckResults;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Startup checks - validates required tools and environment
+ */