autohand-cli 0.7.14 → 0.8.0

package/dist/chunk-7UOUW76C.js

@@ -0,0 +1,603 @@
+import {
+  GitIgnoreParser
+} from "./chunk-EZMINVLU.js";
+
+// src/actions/filesystem.ts
+import fs from "fs-extra";
+import path from "path";
+import { spawnSync } from "child_process";
+import { applyPatch as applyUnifiedPatch } from "diff";
+var FILE_LIMITS = {
+  /** Maximum file size for read operations (10MB) */
+  MAX_READ_SIZE: 10 * 1024 * 1024,
+  /** Maximum file size for write operations (50MB) */
+  MAX_WRITE_SIZE: 50 * 1024 * 1024,
+  /** Maximum number of files in a single directory listing */
+  MAX_DIR_ENTRIES: 1e4,
+  /** Maximum search results to return */
+  MAX_SEARCH_RESULTS: 1e3,
+  /** Maximum undo stack size */
+  MAX_UNDO_STACK: 100
+};
+var FileActionManager = class {
+  constructor(workspaceRoot, additionalDirs = []) {
+    this.undoStack = [];
+    // Preview mode state
+    this.previewMode = false;
+    this.pendingChanges = [];
+    this.batchId = null;
+    this.changeCounter = 0;
+    this.onBatchChange = null;
+    this.currentToolId = "";
+    this.currentToolName = "";
+    const resolvedRoot = path.resolve(workspaceRoot);
+    try {
+      this.workspaceRoot = fs.realpathSync(resolvedRoot);
+    } catch {
+      this.workspaceRoot = resolvedRoot;
+    }
+    this.additionalDirs = [];
+    for (const dir of additionalDirs) {
+      if (!dir || dir.trim() === "") {
+        throw new Error("Empty string is not a valid additional directory");
+      }
+      const resolved = path.resolve(dir);
+      let normalized;
+      try {
+        normalized = fs.realpathSync(resolved);
+      } catch {
+        normalized = resolved;
+      }
+      if (normalized.endsWith(path.sep) && normalized.length > 1) {
+        normalized = normalized.slice(0, -1);
+      }
+      if (!this.additionalDirs.includes(normalized)) {
+        this.additionalDirs.push(normalized);
+      }
+    }
+  }
+  /**
+   * Get all allowed directories (workspace root + additional dirs)
+   */
+  getAllowedDirectories() {
+    return [this.workspaceRoot, ...this.additionalDirs];
+  }
+  /**
+   * Add a new additional directory at runtime (for /add-dir command)
+   */
+  addAdditionalDirectory(dir) {
+    if (!dir || dir.trim() === "") {
+      throw new Error("Empty string is not a valid additional directory");
+    }
+    const resolved = path.resolve(dir);
+    let normalized;
+    try {
+      normalized = fs.realpathSync(resolved);
+    } catch {
+      normalized = resolved;
+    }
+    if (normalized.endsWith(path.sep) && normalized.length > 1) {
+      normalized = normalized.slice(0, -1);
+    }
+    if (!this.additionalDirs.includes(normalized) && normalized !== this.workspaceRoot) {
+      this.additionalDirs.push(normalized);
+    }
+  }
+  /**
+   * Enter preview mode - changes will be batched instead of written
+   */
+  enterPreviewMode(batchId, onBatchChange) {
+    this.previewMode = true;
+    this.batchId = batchId;
+    this.pendingChanges = [];
+    this.changeCounter = 0;
+    this.onBatchChange = onBatchChange ?? null;
+  }
+  /**
+   * Exit preview mode
+   */
+  exitPreviewMode() {
+    this.previewMode = false;
+    this.batchId = null;
+    this.onBatchChange = null;
+  }
+  /**
+   * Check if in preview mode
+   */
+  isInPreviewMode() {
+    return this.previewMode;
+  }
+  /**
+   * Get current batch ID
+   */
+  getBatchId() {
+    return this.batchId;
+  }
+  /**
+   * Set current tool context for batched changes
+   */
+  setCurrentTool(toolId, toolName) {
+    this.currentToolId = toolId;
+    this.currentToolName = toolName;
+  }
+  /**
+   * Get all pending changes
+   */
+  getPendingChanges() {
+    return [...this.pendingChanges];
+  }
+  /**
+   * Clear pending changes without applying
+   */
+  clearPendingChanges() {
+    this.pendingChanges = [];
+    this.changeCounter = 0;
+  }
+  /**
+   * Apply pending changes (selected or all)
+   */
+  async applyPendingChanges(changeIds) {
+    const changesToApply = changeIds ? this.pendingChanges.filter((c) => changeIds.includes(c.id)) : this.pendingChanges;
+    const applied = [];
+    const errors = [];
+    const wasPreviewMode = this.previewMode;
+    this.previewMode = false;
+    for (const change of changesToApply) {
+      try {
+        const fullPath = this.resolvePath(change.filePath);
+        if (change.changeType === "delete") {
+          await fs.remove(fullPath);
+        } else {
+          await fs.ensureDir(path.dirname(fullPath));
+          await fs.writeFile(fullPath, change.proposedContent, "utf8");
+        }
+        applied.push(change.id);
+      } catch (err) {
+        errors.push({
+          id: change.id,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    this.previewMode = wasPreviewMode;
+    const appliedSet = new Set(applied);
+    this.pendingChanges = this.pendingChanges.filter((c) => !appliedSet.has(c.id));
+    return { applied, errors };
+  }
+  /**
+   * Add a change to the pending batch (internal use)
+   */
+  addBatchedChange(filePath, changeType, originalContent, proposedContent, description) {
+    const change = {
+      id: `change_${this.batchId}_${++this.changeCounter}`,
+      filePath,
+      changeType,
+      originalContent,
+      proposedContent,
+      description,
+      toolId: this.currentToolId,
+      toolName: this.currentToolName
+    };
+    this.pendingChanges.push(change);
+    if (this.onBatchChange) {
+      this.onBatchChange(change);
+    }
+  }
+  get root() {
+    return this.workspaceRoot;
+  }
+  async readFile(target) {
+    const filePath = this.resolvePath(target);
+    const exists = await fs.pathExists(filePath);
+    if (!exists) {
+      throw new Error(`File ${target} not found in workspace.`);
+    }
+    const stats = await fs.stat(filePath);
+    if (stats.size > FILE_LIMITS.MAX_READ_SIZE) {
+      const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
+      const limitMB = (FILE_LIMITS.MAX_READ_SIZE / 1024 / 1024).toFixed(0);
+      throw new Error(`File ${target} is too large (${sizeMB}MB). Maximum allowed: ${limitMB}MB`);
+    }
+    return fs.readFile(filePath, "utf8");
+  }
+  async writeFile(target, contents, description) {
+    const contentSize = Buffer.byteLength(contents, "utf8");
+    if (contentSize > FILE_LIMITS.MAX_WRITE_SIZE) {
+      const sizeMB = (contentSize / 1024 / 1024).toFixed(2);
+      const limitMB = (FILE_LIMITS.MAX_WRITE_SIZE / 1024 / 1024).toFixed(0);
+      throw new Error(`Content too large to write (${sizeMB}MB). Maximum allowed: ${limitMB}MB`);
+    }
+    const filePath = this.resolvePath(target);
+    const exists = await fs.pathExists(filePath);
+    const previous = exists ? await fs.readFile(filePath, "utf8") : "";
+    const changeType = exists ? "modify" : "create";
+    if (this.previewMode) {
+      this.addBatchedChange(
+        target,
+        changeType,
+        previous,
+        contents,
+        description ?? `${changeType === "create" ? "Create" : "Modify"} ${target}`
+      );
+      return;
+    }
+    await fs.ensureDir(path.dirname(filePath));
+    if (this.undoStack.length >= FILE_LIMITS.MAX_UNDO_STACK) {
+      this.undoStack.shift();
+    }
+    this.undoStack.push({ absolutePath: filePath, previousContents: previous });
+    await fs.writeFile(filePath, contents, "utf8");
+  }
+  async appendFile(target, contents) {
+    const current = await this.readFileSafe(target);
+    await this.writeFile(target, `${current}${contents}`);
+  }
+  async applyPatch(target, patch, description) {
+    const filePath = this.resolvePath(target);
+    const current = await this.readFileSafe(target);
+    const updated = applyUnifiedPatch(current, patch);
+    if (updated === false) {
+      throw new Error(`Failed to apply patch to ${target}`);
+    }
+    if (this.previewMode) {
+      this.addBatchedChange(
+        target,
+        "modify",
+        current,
+        updated,
+        description ?? `Apply patch to ${target}`
+      );
+      return;
+    }
+    this.undoStack.push({ absolutePath: filePath, previousContents: current });
+    await fs.writeFile(filePath, updated, "utf8");
+  }
+  async undoLast() {
+    const entry = this.undoStack.pop();
+    if (!entry) {
+      throw new Error("Undo stack is empty");
+    }
+    await fs.writeFile(entry.absolutePath, entry.previousContents, "utf8");
+  }
+  search(query, relativePath) {
+    const searchDir = this.resolvePath(relativePath ?? ".");
+    const rgResult = spawnSync("rg", [
+      "--line-number",
+      "--color",
+      "never",
+      "--no-binary",
+      // Skip binary files
+      "--max-count",
+      String(FILE_LIMITS.MAX_SEARCH_RESULTS),
+      // Enforce result limit
+      "--glob",
+      "!*.{exe,dll,so,dylib,bin,o,a,lib,pyc,pyo,class,jar,war,ear}",
+      "--glob",
+      "!*.{png,jpg,jpeg,gif,bmp,ico,svg,webp,tiff}",
+      "--glob",
+      "!*.{mp3,mp4,avi,mov,mkv,wav,flac,ogg,webm}",
+      "--glob",
+      "!*.{pdf,doc,docx,xls,xlsx,ppt,pptx}",
+      "--glob",
+      "!*.{zip,tar,gz,bz2,7z,rar,dmg,iso}",
+      "--glob",
+      "!*.{woff,woff2,ttf,eot,otf}",
+      "--glob",
+      "!**/node_modules/**",
+      "--glob",
+      "!**/.git/**",
+      "--glob",
+      "!**/dist/**",
+      "--glob",
+      "!**/build/**",
+      "--glob",
+      "!**/binaries/**",
+      query,
+      "."
+    ], {
+      cwd: searchDir,
+      encoding: "utf8"
+    });
+    if (rgResult.status === 0 && rgResult.stdout) {
+      const results = rgResult.stdout.trim().split("\n").filter(Boolean).slice(0, FILE_LIMITS.MAX_SEARCH_RESULTS).map((line) => {
+        const [file, lineNo, ...rest] = line.split(":");
+        return {
+          file: path.relative(this.workspaceRoot, path.join(searchDir, file)),
+          line: Number(lineNo),
+          text: rest.join(":")
+        };
+      });
+      return results;
+    }
+    return this.walkFallback(query, searchDir);
+  }
+  searchWithContext(query, options = {}) {
+    const limit = options.limit ?? 10;
+    const contextLines = options.context ?? 2;
+    const results = this.search(query, options.relativePath);
+    return results.slice(0, limit).map((hit) => this.renderContext(hit, contextLines)).join("\n\n");
+  }
+  semanticSearch(query, opts = {}) {
+    const limit = opts.limit ?? 5;
+    const window = opts.window ?? 400;
+    const baseDir = this.resolvePath(opts.relativePath ?? ".");
+    const ignoreFilter = new GitIgnoreParser(baseDir);
+    const results = [];
+    const stack = [baseDir];
+    const lowerQuery = query.toLowerCase();
+    while (stack.length && results.length < limit) {
+      const current = stack.pop();
+      if (!current) continue;
+      const relative = path.relative(this.workspaceRoot, current);
+      const normalizedRel = relative.replace(/\\/g, "/");
+      if (path.basename(current).startsWith(".") || ignoreFilter.isIgnored(normalizedRel)) {
+        continue;
+      }
+      try {
+        const stats = fs.statSync(current);
+        if (stats.isDirectory()) {
+          const entries = fs.readdirSync(current);
+          for (const entry of entries) {
+            if (!entry.startsWith(".")) {
+              stack.push(path.join(current, entry));
+            }
+          }
+          continue;
+        }
+        if (!stats.isFile()) {
+          continue;
+        }
+        const ext = path.extname(current).toLowerCase();
+        const binaryExtensions = /* @__PURE__ */ new Set([
+          ".exe",
+          ".dll",
+          ".so",
+          ".dylib",
+          ".bin",
+          ".o",
+          ".a",
+          ".lib",
+          ".pyc",
+          ".pyo",
+          ".class",
+          ".jar",
+          ".war",
+          ".ear",
+          ".png",
+          ".jpg",
+          ".jpeg",
+          ".gif",
+          ".bmp",
+          ".ico",
+          ".svg",
+          ".webp",
+          ".tiff",
+          ".mp3",
+          ".mp4",
+          ".avi",
+          ".mov",
+          ".mkv",
+          ".wav",
+          ".flac",
+          ".ogg",
+          ".webm",
+          ".pdf",
+          ".doc",
+          ".docx",
+          ".xls",
+          ".xlsx",
+          ".ppt",
+          ".pptx",
+          ".zip",
+          ".tar",
+          ".gz",
+          ".bz2",
+          ".7z",
+          ".rar",
+          ".dmg",
+          ".iso",
+          ".woff",
+          ".woff2",
+          ".ttf",
+          ".eot",
+          ".otf"
+        ]);
+        if (binaryExtensions.has(ext)) {
+          continue;
+        }
+        if (normalizedRel.includes("node_modules/") || normalizedRel.includes("/dist/") || normalizedRel.includes("/build/") || normalizedRel.includes("/binaries/")) {
+          continue;
+        }
+        const contents = fs.readFileSync(current, "utf8");
+        const haystack = contents.toLowerCase();
+        const idx = haystack.indexOf(lowerQuery);
+        if (idx === -1) continue;
+        const start = Math.max(0, idx - window);
+        const end = Math.min(contents.length, idx + query.length + window);
+        const prefixEllipsis = start > 0 ? "\u2026" : "";
+        const suffixEllipsis = end < contents.length ? "\u2026" : "";
+        const snippet = `${prefixEllipsis}${contents.slice(start, end)}${suffixEllipsis}`;
+        results.push({
+          file: normalizedRel || path.basename(current),
+          snippet
+        });
+      } catch {
+        continue;
+      }
+    }
+    return results;
+  }
+  async readFileSafe(target) {
+    const filePath = this.resolvePath(target);
+    if (!await fs.pathExists(filePath)) {
+      return "";
+    }
+    const stats = await fs.stat(filePath);
+    if (stats.size > FILE_LIMITS.MAX_READ_SIZE) {
+      const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
+      const limitMB = (FILE_LIMITS.MAX_READ_SIZE / 1024 / 1024).toFixed(0);
+      throw new Error(`File ${target} is too large (${sizeMB}MB). Maximum allowed: ${limitMB}MB`);
+    }
+    return fs.readFile(filePath, "utf8");
+  }
+  resolvePath(target) {
+    const normalized = path.isAbsolute(target) ? target : path.join(this.workspaceRoot, target);
+    const resolved = path.resolve(normalized);
+    let realPath;
+    try {
+      realPath = fs.realpathSync(resolved);
+    } catch {
+      const parentDir = path.dirname(resolved);
+      try {
+        const realParent = fs.realpathSync(parentDir);
+        realPath = path.join(realParent, path.basename(resolved));
+      } catch {
+        realPath = resolved;
+      }
+    }
+    const allAllowedRoots = [this.workspaceRoot, ...this.additionalDirs];
+    for (const allowedRoot of allAllowedRoots) {
+      let realRoot;
+      try {
+        realRoot = fs.realpathSync(allowedRoot);
+      } catch {
+        realRoot = allowedRoot;
+      }
+      const rootWithSep = realRoot.endsWith(path.sep) ? realRoot : `${realRoot}${path.sep}`;
+      if (realPath === realRoot || realPath.startsWith(rootWithSep)) {
+        return resolved;
+      }
+    }
+    const allowedDirsList = allAllowedRoots.join(", ");
+    throw new Error(`Path ${target} escapes the allowed directories: ${allowedDirsList}`);
+  }
+  walkFallback(query, baseDir) {
+    const hits = [];
+    const stack = [baseDir];
+    while (stack.length && hits.length < FILE_LIMITS.MAX_SEARCH_RESULTS) {
+      const current = stack.pop();
+      if (!current) {
+        continue;
+      }
+      const basename = path.basename(current);
+      const relative = path.relative(this.workspaceRoot, current);
+      if (basename.startsWith(".") || relative.includes("node_modules") || relative.startsWith("dist")) {
+        continue;
+      }
+      try {
+        const stats = fs.statSync(current);
+        if (stats.isDirectory()) {
+          const entries = fs.readdirSync(current);
+          for (const entry of entries) {
+            if (!entry.startsWith(".")) {
+              stack.push(path.join(current, entry));
+            }
+          }
+        } else if (stats.isFile()) {
+          const contents = fs.readFileSync(current, "utf8");
+          const lines = contents.split(/\r?\n/);
+          for (let idx = 0; idx < lines.length && hits.length < FILE_LIMITS.MAX_SEARCH_RESULTS; idx++) {
+            const line = lines[idx];
+            if (line.includes(query)) {
+              hits.push({
+                file: path.relative(this.workspaceRoot, current),
+                line: idx + 1,
+                text: line.trim()
+              });
+            }
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+    return hits;
+  }
+  async createDirectory(relativePath) {
+    const dirPath = this.resolvePath(relativePath);
+    await fs.ensureDir(dirPath);
+  }
+  async listDirectory(relativePath) {
+    const dirPath = this.resolvePath(relativePath);
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    if (entries.length > FILE_LIMITS.MAX_DIR_ENTRIES) {
+      throw new Error(`Directory has too many entries (${entries.length}). Maximum allowed: ${FILE_LIMITS.MAX_DIR_ENTRIES}`);
+    }
+    return entries.map((entry) => ({
+      name: entry.name,
+      isDirectory: entry.isDirectory()
+    }));
+  }
+  async deletePath(relativePath, description) {
+    const fullPath = this.resolvePath(relativePath);
+    const exists = await fs.pathExists(fullPath);
+    if (!exists) {
+      throw new Error(`${relativePath} does not exist.`);
+    }
+    const stats = await fs.stat(fullPath);
+    const previousContents = stats.isFile() ? await fs.readFile(fullPath, "utf8") : "";
+    if (this.previewMode) {
+      this.addBatchedChange(
+        relativePath,
+        "delete",
+        previousContents,
+        "",
+        description ?? `Delete ${relativePath}`
+      );
+      return;
+    }
+    this.undoStack.push({
+      absolutePath: fullPath,
+      previousContents
+    });
+    await fs.remove(fullPath);
+  }
+  async renamePath(from, to) {
+    const fromPath = this.resolvePath(from);
+    const toPath = this.resolvePath(to);
+    await fs.ensureDir(path.dirname(toPath));
+    await fs.move(fromPath, toPath, { overwrite: true });
+  }
+  async copyPath(from, to) {
+    const fromPath = this.resolvePath(from);
+    const toPath = this.resolvePath(to);
+    await fs.copy(fromPath, toPath, { overwrite: true });
+  }
+  async replaceInFile(relativePath, searchValue, replaceValue) {
+    const current = await this.readFile(relativePath);
+    const updated = current.replace(searchValue, replaceValue);
+    await this.writeFile(relativePath, updated);
+  }
+  async formatFile(relativePath, formatter) {
+    const current = await this.readFile(relativePath);
+    const formatted = await formatter(current, relativePath);
+    await this.writeFile(relativePath, formatted);
+  }
+  renderContext(hit, contextLines) {
+    const filePath = this.resolvePath(hit.file);
+    if (!fs.existsSync(filePath)) {
+      return `${hit.file}:${hit.line}`;
+    }
+    const contents = fs.readFileSync(filePath, "utf8");
+    const lines = contents.split(/\r?\n/);
+    const start = Math.max(0, hit.line - 1 - contextLines);
+    const end = Math.min(lines.length, hit.line - 1 + contextLines + 1);
+    const snippet = lines.slice(start, end).map((line, idx) => {
+      const number = start + idx + 1;
+      const marker = number === hit.line ? ">" : " ";
+      return `${marker} ${number.toString().padStart(4, " ")} | ${line}`;
+    });
+    return `${hit.file}:${hit.line}
+${snippet.join("\n")}`;
+  }
+};
+
+export {
+  FILE_LIMITS,
+  FileActionManager
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */