@aigne/doc-smith 0.8.11-beta.5 → 0.8.11-beta.7

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

@@ -0,0 +1,317 @@
+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"],
+};

package/agents/update/fs-tools/read-file.mjs

@@ -0,0 +1,307 @@
+import fs from "node:fs";
+import fsPromises from "node:fs/promises";
+import path from "node:path";
+
+/**
+ * Detects if a file is likely binary by checking for null bytes
+ */
+function isBinaryFile(buffer) {
+  // Check first 8KB for null bytes
+  const checkLength = Math.min(buffer.length, 8192);
+  for (let i = 0; i < checkLength; i++) {
+    if (buffer[i] === 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Gets MIME type based on file extension
+ */
+function getMimeType(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const mimeTypes = {
+    // Text files
+    ".txt": "text/plain",
+    ".md": "text/markdown",
+    ".json": "application/json",
+    ".js": "text/javascript",
+    ".mjs": "text/javascript",
+    ".ts": "text/typescript",
+    ".tsx": "text/typescript",
+    ".jsx": "text/javascript",
+    ".py": "text/x-python",
+    ".java": "text/x-java",
+    ".cpp": "text/x-c",
+    ".c": "text/x-c",
+    ".h": "text/x-c",
+    ".css": "text/css",
+    ".html": "text/html",
+    ".xml": "text/xml",
+    ".yaml": "text/yaml",
+    ".yml": "text/yaml",
+    ".toml": "text/plain",
+    ".ini": "text/plain",
+    ".cfg": "text/plain",
+    ".conf": "text/plain",
+    ".sh": "text/x-shellscript",
+    ".bash": "text/x-shellscript",
+    ".zsh": "text/x-shellscript",
+    ".fish": "text/x-shellscript",
+
+    // Image files
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml",
+    ".bmp": "image/bmp",
+    ".ico": "image/x-icon",
+
+    // Document files
+    ".pdf": "application/pdf",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+
+    // Other
+    ".zip": "application/zip",
+    ".tar": "application/x-tar",
+    ".gz": "application/gzip",
+  };
+
+  return mimeTypes[ext] || "application/octet-stream";
+}
+
+/**
+ * Validates file path and checks accessibility
+ */
+function validateFilePath(filePath) {
+  if (!filePath || typeof filePath !== "string" || filePath.trim() === "") {
+    return "File path parameter is required and cannot be empty";
+  }
+
+  if (!path.isAbsolute(filePath)) {
+    return `File path must be absolute, but was relative: ${filePath}`;
+  }
+
+  try {
+    const stats = fs.statSync(filePath);
+    if (stats.isDirectory()) {
+      return `Path is a directory, not a file: ${filePath}`;
+    }
+    return null;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return `File does not exist: ${filePath}`;
+    } else if (error.code === "EACCES") {
+      return `Permission denied: ${filePath}`;
+    }
+    return `Cannot access file: ${filePath} (${error.message})`;
+  }
+}
+
+/**
+ * Reads file content with proper handling for different file types
+ */
+async function readFileContent(filePath, offset = 0, limit = null, encoding = "utf8") {
+  const stats = await fsPromises.stat(filePath);
+  const fileSize = stats.size;
+  const mimeType = getMimeType(filePath);
+
+  // Handle binary files differently
+  if (
+    mimeType.startsWith("image/") ||
+    mimeType === "application/pdf" ||
+    fileSize > 10 * 1024 * 1024
+  ) {
+    return {
+      content: `[Binary file: ${path.basename(filePath)}]`,
+      mimeType,
+      fileSize,
+      isBinary: true,
+      encoding: null,
+      lineCount: null,
+      isTruncated: false,
+    };
+  }
+
+  // Read file as buffer first to check if it's binary
+  const buffer = await fsPromises.readFile(filePath);
+
+  if (isBinaryFile(buffer)) {
+    return {
+      content: `[Binary file: ${path.basename(filePath)}]`,
+      mimeType,
+      fileSize,
+      isBinary: true,
+      encoding: null,
+      lineCount: null,
+      isTruncated: false,
+    };
+  }
+
+  // Convert buffer to text
+  let content = buffer.toString(encoding);
+  const lines = content.split(/\r?\n/);
+  const totalLines = lines.length;
+  let isTruncated = false;
+  let linesShown = [1, totalLines];
+
+  // Handle offset and limit for text files
+  if (offset > 0 || limit !== null) {
+    const startLine = Math.max(0, offset);
+    const endLine = limit !== null ? Math.min(startLine + limit, totalLines) : totalLines;
+
+    if (startLine >= totalLines) {
+      return {
+        content: "",
+        mimeType,
+        fileSize,
+        isBinary: false,
+        encoding,
+        lineCount: totalLines,
+        isTruncated: false,
+        linesShown: [startLine + 1, startLine + 1],
+        message: `Offset ${offset} is beyond file end (file has ${totalLines} lines)`,
+      };
+    }
+
+    const selectedLines = lines.slice(startLine, endLine);
+    content = selectedLines.join("\n");
+    isTruncated = startLine > 0 || endLine < totalLines;
+    linesShown = [startLine + 1, endLine];
+  }
+
+  // Auto-truncate very large files (more than 10000 lines)
+  const maxLines = 10000;
+  if (limit === null && totalLines > maxLines) {
+    const selectedLines = lines.slice(0, maxLines);
+    content = selectedLines.join("\n");
+    isTruncated = true;
+    linesShown = [1, maxLines];
+  }
+
+  return {
+    content,
+    mimeType,
+    fileSize,
+    isBinary: false,
+    encoding,
+    lineCount: totalLines,
+    isTruncated,
+    linesShown,
+  };
+}
+
+export default async function readFile({ path: filePath, offset, limit, encoding = "utf8" }) {
+  let result = {};
+  let error = null;
+
+  try {
+    // Validate file path first (this checks if it's absolute)
+    const pathError = validateFilePath(filePath);
+    if (pathError) {
+      throw new Error(pathError);
+    }
+
+    // Now we know filePath is valid and absolute
+
+    // Validate numeric parameters
+    if (offset !== undefined && (typeof offset !== "number" || offset < 0)) {
+      throw new Error("Offset must be a non-negative number");
+    }
+
+    if (limit !== undefined && (typeof limit !== "number" || limit <= 0)) {
+      throw new Error("Limit must be a positive number");
+    }
+
+    // Read file content
+    const fileResult = await readFileContent(filePath, offset, limit, encoding);
+
+    // Build success result
+    result = {
+      content: fileResult.content,
+      metadata: {
+        path: filePath,
+        mimeType: fileResult.mimeType,
+        fileSize: fileResult.fileSize,
+        isBinary: fileResult.isBinary,
+        encoding: fileResult.encoding,
+        lineCount: fileResult.lineCount,
+      },
+    };
+
+    // Add truncation info if applicable
+    if (fileResult.isTruncated) {
+      result.truncated = {
+        isTruncated: true,
+        linesShown: fileResult.linesShown,
+        totalLines: fileResult.lineCount,
+        nextOffset: fileResult.linesShown[1],
+      };
+
+      // Add helpful message for truncated content
+      const [start, end] = fileResult.linesShown;
+      const nextOffset = end;
+      result.message =
+        `Content truncated. Showing lines ${start}-${end} of ${fileResult.lineCount} total lines. ` +
+        `To read more, use offset: ${nextOffset}.`;
+    }
+
+    // Add message if provided
+    if (fileResult.message) {
+      result.message = fileResult.message;
+    }
+  } catch (err) {
+    error = err;
+    result = {
+      content: null,
+      metadata: {
+        path: filePath,
+        mimeType: null,
+        fileSize: null,
+        isBinary: null,
+        encoding: null,
+        lineCount: null,
+      },
+      message: `Error reading file: ${err.message}`,
+    };
+  }
+
+  return {
+    command: "read_file",
+    arguments: {
+      path: filePath,
+      offset,
+      limit,
+      encoding,
+    },
+    result,
+    error: error && { message: error.message },
+  };
+}
+
+readFile.input_schema = {
+  type: "object",
+  properties: {
+    path: {
+      type: "string",
+      description: "The path to the file to read (for backwards compatibility)",
+    },
+    offset: {
+      type: "number",
+      description: "Optional: The 0-based line number to start reading from",
+    },
+    limit: {
+      type: "number",
+      description: "Optional: Maximum number of lines to read",
+    },
+    encoding: {
+      type: "string",
+      description: "Optional: File encoding (defaults to utf8)",
+    },
+  },
+  required: ["path"],
+};

package/agents/update/generate-document.yaml

@@ -41,14 +41,11 @@ input_schema:
     - rules
     - datasources
     - originalDocumentStructure
-output_schema:
-  type: object
-  properties:
-    content:
-      type: string
-  required:
-    - content
+output_key: content
 skills:
+  - fs-tools/glob.mjs
+  - fs-tools/grep.mjs
+  - fs-tools/read-file.mjs
   - type: team
     task_render_mode: collapse
     name: generateD2DiagramContent

package/agents/update/update-document-detail.yaml

@@ -39,14 +39,10 @@ input_schema:
   required:
     - originalContent
     - feedback
-output_schema:
-  type: object
-  properties:
-    updatedContent:
-      type: string
-      description: Final updated markdown content after applying modifications
-    operationSummary:
-      type: string
-      description: Summary of the operations performed on the document content
+output_key: message
 skills:
-  - ./document-tools/update-document-content.mjs
+  - ./document-tools/update-document-content.mjs
+  - ./fs-tools/glob.mjs
+  - ./fs-tools/grep.mjs
+  - ./fs-tools/read-file.mjs
+task_render_mode: collapse