@aigne/doc-smith 0.8.12-beta.6 → 0.8.12-beta.8

package/agents/update/fs-tools/glob.mjs

@@ -1,184 +0,0 @@
-import fs from "node:fs";
-import fsPromises from "node:fs/promises";
-import path from "node:path";
-
-/**
- * Sorts files by modification time (newest first), then alphabetically
- */
-function sortFilesByModTime(files, basePath) {
-  return files
-    .map((file) => {
-      const fullPath = path.isAbsolute(file) ? file : path.resolve(basePath, file);
-      try {
-        const stats = fs.statSync(fullPath);
-        return {
-          path: file,
-          fullPath,
-          mtime: stats.mtimeMs || 0,
-        };
-      } catch {
-        return {
-          path: file,
-          fullPath,
-          mtime: 0,
-        };
-      }
-    })
-    .sort((a, b) => {
-      // Sort by modification time (newest first), then alphabetically
-      if (b.mtime !== a.mtime) {
-        return b.mtime - a.mtime;
-      }
-      return a.path.localeCompare(b.path);
-    })
-    .map((item) => item.path);
-}
-
-/**
- * Filters out common ignore patterns
- */
-function shouldIgnoreFile(filePath) {
-  const ignorePatterns = [
-    "node_modules",
-    ".git",
-    ".DS_Store",
-    ".vscode",
-    ".idea",
-    "dist",
-    "build",
-    "*.log",
-    "coverage",
-    ".nyc_output",
-    ".cache",
-  ];
-
-  const normalizedPath = filePath.replace(/\\/g, "/");
-
-  return ignorePatterns.some((pattern) => {
-    if (pattern.includes("*")) {
-      // Simple wildcard matching for patterns like "*.log"
-      const regex = new RegExp(pattern.replace(/\*/g, ".*"));
-      return regex.test(path.basename(normalizedPath));
-    } else {
-      // Directory or file name matching
-      return (
-        normalizedPath.includes(`/${pattern}/`) ||
-        normalizedPath.endsWith(`/${pattern}`) ||
-        normalizedPath.startsWith(`${pattern}/`) ||
-        normalizedPath === pattern
-      );
-    }
-  });
-}
-
-export default async function glob({
-  pattern,
-  case_sensitive = false,
-  respect_git_ignore = true,
-  limit = 100,
-}) {
-  let result = [];
-  let error = null;
-  const searchDir = process.cwd();
-
-  try {
-    // Validate required parameters
-    if (!pattern || typeof pattern !== "string" || pattern.trim() === "") {
-      throw new Error("Pattern parameter is required and cannot be empty");
-    }
-
-    // Use Node.js built-in glob
-    const globOptions = {
-      cwd: searchDir,
-      nodir: true, // Only return files, not directories
-      dot: true, // Include hidden files
-    };
-
-    // Note: Node.js fs.glob doesn't support case_sensitive option directly
-    // We'll handle case sensitivity in post-processing if needed
-    const iter = fsPromises.glob(pattern, globOptions);
-    const files = [];
-
-    for await (const file of iter) {
-      if (files.length >= limit) break;
-
-      // Apply ignore filters
-      if (shouldIgnoreFile(file)) {
-        continue;
-      }
-
-      // Handle case sensitivity if needed
-      if (case_sensitive === false) {
-        // Node.js glob is case-sensitive by default on most systems
-        // For case-insensitive matching, we rely on the pattern itself
-        // or the filesystem behavior
-      }
-
-      files.push(file);
-    }
-
-    // Sort files by modification time (newest first)
-    const sortedFiles = sortFilesByModTime(files, searchDir);
-
-    // Build result message
-    let message;
-    if (sortedFiles.length === 0) {
-      message = `No files found matching pattern "${pattern}"`;
-    } else {
-      const fileCount = sortedFiles.length;
-      const truncated = files.length >= limit;
-      message = `Found ${fileCount}${truncated ? "+" : ""} file(s) matching "${pattern}"`;
-      message += ", sorted by modification time (newest first):";
-    }
-
-    result = {
-      files: sortedFiles,
-      count: sortedFiles.length,
-      message,
-      truncated: files.length >= limit,
-    };
-  } catch (err) {
-    error = err;
-    result = {
-      files: [],
-      count: 0,
-      message: `Error during glob search: ${err.message}`,
-      truncated: false,
-    };
-  }
-
-  return {
-    command: "glob",
-    arguments: {
-      pattern,
-      case_sensitive,
-      respect_git_ignore,
-      limit,
-    },
-    result,
-    error: error && { message: error.message },
-  };
-}
-
-glob.input_schema = {
-  type: "object",
-  properties: {
-    pattern: {
-      type: "string",
-      description: 'The glob pattern to match files against (e.g., "**/*.js", "src/**/*.ts")',
-    },
-    case_sensitive: {
-      type: "boolean",
-      description: "Optional: Whether the search should be case-sensitive (defaults to false)",
-    },
-    respect_git_ignore: {
-      type: "boolean",
-      description: "Optional: Whether to respect .gitignore patterns (defaults to true)",
-    },
-    limit: {
-      type: "number",
-      description: "Optional: Maximum number of files to return (defaults to 100)",
-    },
-  },
-  required: ["pattern"],
-};

package/agents/update/fs-tools/grep.mjs

@@ -1,317 +0,0 @@
-import childProcess from "node:child_process";
-import fs from "node:fs";
-import fsPromises from "node:fs/promises";
-import { EOL } from "node:os";
-import path from "node:path";
-
-/**
- * Checks if a command is available in the system's PATH
- */
-function isCommandAvailable(command) {
-  return new Promise((resolve) => {
-    const checkCommand = process.platform === "win32" ? "where" : "command";
-    const checkArgs = process.platform === "win32" ? [command] : ["-v", command];
-
-    try {
-      const child = childProcess.spawn(checkCommand, checkArgs, {
-        stdio: "ignore",
-        shell: process.platform === "win32",
-      });
-      child.on("close", (code) => resolve(code === 0));
-      child.on("error", () => resolve(false));
-    } catch {
-      resolve(false);
-    }
-  });
-}
-
-/**
- * Checks if a directory is a git repository
- */
-function isGitRepository(dir) {
-  try {
-    const gitDir = path.join(dir, ".git");
-    return fs.existsSync(gitDir);
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Parses grep output in format: filePath:lineNumber:lineContent
- */
-function parseGrepOutput(output, basePath) {
-  const results = [];
-  if (!output) return results;
-
-  const lines = output.split(EOL);
-
-  for (const line of lines) {
-    if (!line.trim()) continue;
-
-    const firstColonIndex = line.indexOf(":");
-    if (firstColonIndex === -1) continue;
-
-    const secondColonIndex = line.indexOf(":", firstColonIndex + 1);
-    if (secondColonIndex === -1) continue;
-
-    const filePathRaw = line.substring(0, firstColonIndex);
-    const lineNumberStr = line.substring(firstColonIndex + 1, secondColonIndex);
-    const lineContent = line.substring(secondColonIndex + 1);
-
-    const lineNumber = parseInt(lineNumberStr, 10);
-    if (!Number.isNaN(lineNumber)) {
-      const relativePath = path.relative(basePath, path.resolve(basePath, filePathRaw));
-      results.push({
-        filePath: relativePath || path.basename(filePathRaw),
-        lineNumber,
-        line: lineContent,
-      });
-    }
-  }
-  return results;
-}
-
-/**
- * Performs grep search using multiple strategies
- */
-async function performGrepSearch({ pattern, include }) {
-  const absolutePath = path.resolve(".");
-
-  // Strategy 1: git grep
-  const isGit = isGitRepository(absolutePath);
-  const gitAvailable = isGit && (await isCommandAvailable("git"));
-
-  if (gitAvailable) {
-    try {
-      const gitArgs = ["grep", "--untracked", "-n", "-E", "--ignore-case", pattern];
-      if (include) {
-        gitArgs.push("--", include);
-      }
-
-      const output = await new Promise((resolve, reject) => {
-        const child = childProcess.spawn("git", gitArgs, {
-          cwd: absolutePath,
-          windowsHide: true,
-        });
-
-        let stdout = "";
-        let stderr = "";
-
-        child.stdout.on("data", (chunk) => {
-          stdout += chunk;
-        });
-        child.stderr.on("data", (chunk) => {
-          stderr += chunk;
-        });
-        child.on("error", (err) => reject(new Error(`Failed to start git grep: ${err.message}`)));
-        child.on("close", (code) => {
-          if (code === 0) resolve(stdout);
-          else if (code === 1)
-            resolve(""); // No matches
-          else reject(new Error(`git grep exited with code ${code}: ${stderr}`));
-        });
-      });
-
-      return parseGrepOutput(output, absolutePath);
-    } catch (gitError) {
-      console.debug(`git grep failed: ${gitError.message}. Falling back...`);
-    }
-  }
-
-  // Strategy 2: System grep
-  const grepAvailable = await isCommandAvailable("grep");
-  if (grepAvailable) {
-    try {
-      const grepArgs = [
-        "-r",
-        "-n",
-        "-H",
-        "-E",
-        "-i",
-        "--exclude-dir=node_modules",
-        "--exclude-dir=.git",
-      ];
-      if (include) {
-        grepArgs.push(`--include=${include}`);
-      }
-      grepArgs.push(pattern, ".");
-
-      const output = await new Promise((resolve, reject) => {
-        const child = childProcess.spawn("grep", grepArgs, {
-          cwd: absolutePath,
-          windowsHide: true,
-        });
-
-        let stdout = "";
-        let stderr = "";
-
-        child.stdout.on("data", (chunk) => {
-          stdout += chunk;
-        });
-        child.stderr.on("data", (chunk) => {
-          const stderrStr = chunk.toString();
-          // Suppress common harmless stderr messages
-          if (
-            !stderrStr.includes("Permission denied") &&
-            !/grep:.*: Is a directory/i.test(stderrStr)
-          ) {
-            stderr += chunk;
-          }
-        });
-        child.on("error", (err) =>
-          reject(new Error(`Failed to start system grep: ${err.message}`)),
-        );
-        child.on("close", (code) => {
-          if (code === 0) resolve(stdout);
-          else if (code === 1)
-            resolve(""); // No matches
-          else {
-            if (stderr.trim()) reject(new Error(`System grep exited with code ${code}: ${stderr}`));
-            else resolve(""); // Exit code > 1 but no stderr, likely just suppressed errors
-          }
-        });
-      });
-
-      return parseGrepOutput(output, absolutePath);
-    } catch (grepError) {
-      console.debug(`System grep failed: ${grepError.message}. Falling back...`);
-    }
-  }
-
-  // Strategy 3: JavaScript fallback
-  console.debug("Falling back to JavaScript grep implementation.");
-  const matches = [];
-
-  // Escape regex special characters in a string
-  function escapeRegExp(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  }
-
-  try {
-    const regex = new RegExp(pattern, "i");
-
-    async function searchDirectory(dir) {
-      const entries = await fsPromises.readdir(dir, { withFileTypes: true });
-
-      for (const entry of entries) {
-        if (entry.name.startsWith(".") && entry.name !== ".") continue;
-        if (entry.name === "node_modules") continue;
-
-        const fullPath = path.join(dir, entry.name);
-
-        if (entry.isDirectory()) {
-          await searchDirectory(fullPath);
-        } else if (entry.isFile()) {
-          // Apply include filter if specified
-          if (include) {
-            let patternStr = escapeRegExp(include);
-            patternStr = patternStr.replace(/\\\*/g, ".*").replace(/\\\?/g, ".");
-            const includePattern = `^${patternStr}$`;
-            if (!new RegExp(includePattern).test(entry.name)) {
-              continue;
-            }
-          }
-
-          try {
-            const content = await fsPromises.readFile(fullPath, "utf8");
-            const lines = content.split(/\r?\n/);
-
-            lines.forEach((line, index) => {
-              if (regex.test(line)) {
-                matches.push({
-                  filePath: path.relative(absolutePath, fullPath),
-                  lineNumber: index + 1,
-                  line,
-                });
-              }
-            });
-          } catch (_readError) {
-            // Ignore read errors (binary files, permissions, etc.)
-          }
-        }
-      }
-    }
-
-    await searchDirectory(absolutePath);
-    return matches;
-  } catch (error) {
-    throw new Error(`JavaScript fallback failed: ${error.message}`);
-  }
-}
-
-export default async function grep({ pattern, include }) {
-  let result = "";
-  let error = null;
-
-  try {
-    // Validate pattern parameter (allow empty string but not undefined/null)
-    if (pattern === undefined || pattern === null) {
-      throw new Error("Pattern parameter is required");
-    }
-
-    // Validate regex pattern
-    try {
-      new RegExp(pattern);
-    } catch (regexError) {
-      throw new Error(`Invalid regular expression pattern: ${pattern}. ${regexError.message}`);
-    }
-
-    const matches = await performGrepSearch({ pattern, include });
-
-    if (matches.length === 0) {
-      result = `No matches found for pattern "${pattern}"${include ? ` (filter: "${include}")` : ""}.`;
-    } else {
-      // Group matches by file
-      const matchesByFile = matches.reduce((acc, match) => {
-        if (!acc[match.filePath]) {
-          acc[match.filePath] = [];
-        }
-        acc[match.filePath].push(match);
-        acc[match.filePath].sort((a, b) => a.lineNumber - b.lineNumber);
-        return acc;
-      }, {});
-
-      const matchCount = matches.length;
-      const matchTerm = matchCount === 1 ? "match" : "matches";
-
-      result = `Found ${matchCount} ${matchTerm} for pattern "${pattern}"${include ? ` (filter: "${include}")` : ""}:\n---\n`;
-
-      for (const filePath in matchesByFile) {
-        result += `File: ${filePath}\n`;
-        matchesByFile[filePath].forEach((match) => {
-          const trimmedLine = match.line.trim();
-          result += `L${match.lineNumber}: ${trimmedLine}\n`;
-        });
-        result += "---\n";
-      }
-
-      result = result.trim();
-    }
-  } catch (e) {
-    error = e;
-    result = `Error during grep search: ${e.message}`;
-  }
-
-  return {
-    command: "grep",
-    arguments: { pattern, include },
-    result,
-    error: error && { message: error.message },
-  };
-}
-
-grep.input_schema = {
-  type: "object",
-  properties: {
-    pattern: {
-      type: "string",
-      description: "The regular expression pattern to search for in file contents",
-    },
-    include: {
-      type: "string",
-      description: 'Optional: File pattern to include in search (e.g. "*.js", "*.{ts,tsx}")',
-    },
-  },
-  required: ["pattern"],
-};