@oisheek_c/codeforge 1.0.1

package/packages/tools/searchFiles.js

@@ -0,0 +1,322 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import {
+  createToolError,
+  resolveProjectPath,
+} from "./filesystem.js";
+import {
+  defineTool,
+} from "../core/tool.js";
+
+const DEFAULT_IGNORE = new Set([
+  ".git",
+  "node_modules",
+  ".pnpm",
+  "dist",
+  "build",
+  "coverage",
+]);
+
+const DEFAULT_MAX_RESULTS = 100;
+const MAX_RESULTS_LIMIT = 500;
+
+
+
+function normalizeMaxResults(value) {
+  if (value == null) {
+    return DEFAULT_MAX_RESULTS;
+  }
+
+  if (
+    !Number.isInteger(value) ||
+    value < 1 ||
+    value > MAX_RESULTS_LIMIT
+  ) {
+    throw new TypeError(
+      `maxResults must be an integer between 1 and ${MAX_RESULTS_LIMIT}.`
+    );
+  }
+
+  return value;
+}
+
+function normalizePath(filePath, root) {
+  return path
+    .relative(root, filePath)
+    .split(path.sep)
+    .join("/");
+}
+
+async function searchFile({
+  filePath,
+  root,
+  query,
+  caseSensitive,
+  results,
+  maxResults,
+}) {
+  let content;
+
+  try {
+    content = await fs.readFile(
+      filePath,
+      "utf8"
+    );
+  } catch {
+    return;
+  }
+
+  const lines = content.split(/\r?\n/);
+
+  const needle = caseSensitive
+    ? query
+    : query.toLowerCase();
+
+  for (
+    let index = 0;
+    index < lines.length;
+    index += 1
+  ) {
+    const line = lines[index];
+
+    const haystack = caseSensitive
+      ? line
+      : line.toLowerCase();
+
+    if (!haystack.includes(needle)) {
+      continue;
+    }
+
+    results.push({
+      path: normalizePath(
+        filePath,
+        root
+      ),
+
+      line: index + 1,
+
+      text: line,
+    });
+
+    if (results.length >= maxResults) {
+      return;
+    }
+  }
+}
+
+async function walk({
+  directory,
+  root,
+  query,
+  caseSensitive,
+  results,
+  maxResults,
+}) {
+  if (results.length >= maxResults) {
+    return;
+  }
+
+  let entries;
+
+  try {
+    entries = await fs.readdir(
+      directory,
+      {
+        withFileTypes: true,
+      }
+    );
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    if (results.length >= maxResults) {
+      return;
+    }
+
+    if (DEFAULT_IGNORE.has(entry.name)) {
+      continue;
+    }
+
+    const fullPath = path.join(
+      directory,
+      entry.name
+    );
+
+    if (entry.isDirectory()) {
+      await walk({
+        directory: fullPath,
+        root,
+        query,
+        caseSensitive,
+        results,
+        maxResults,
+      });
+
+      continue;
+    }
+
+    if (!entry.isFile()) {
+      continue;
+    }
+
+    await searchFile({
+      filePath: fullPath,
+      root,
+      query,
+      caseSensitive,
+      results,
+      maxResults,
+    });
+  }
+}
+
+export const searchFilesTool = defineTool({
+  name: "search_files",
+
+  description:
+  "Search the contents of project files for literal text and return matching file paths, line numbers, and lines. This tool searches file contents, not file names or paths. If the exact path of a file is already known, use read_file instead.",
+  source: "builtin",
+
+  capabilities: [
+    "filesystem.read",
+    "filesystem.search",
+  ],
+
+  sideEffect: "none",
+
+  approval: "never",
+
+  inputSchema: {
+    type: "object",
+
+    properties: {
+      query: {
+        type: "string",
+        description:
+          "Literal text to search for.",
+      },
+
+      path: {
+        type: "string",
+        description:
+          "Optional project-relative file or directory to search. Defaults to the project root.",
+      },
+
+      caseSensitive: {
+        type: "boolean",
+        description:
+          "Whether matching should be case-sensitive. Defaults to false.",
+      },
+
+      maxResults: {
+        type: "integer",
+        minimum: 1,
+        maximum: MAX_RESULTS_LIMIT,
+        description:
+          "Maximum number of matches to return. Defaults to 100.",
+      },
+    },
+
+    required: [
+      "query",
+    ],
+
+    additionalProperties: false,
+  },
+
+  async execute(
+    input,
+    context = {}
+  ) {
+    if (
+      typeof input?.query !== "string" ||
+      input.query.length === 0
+    ) {
+      throw new TypeError(
+        "query must be a non-empty string."
+      );
+    }
+
+    const searchPath =
+      input.path ?? ".";
+
+    const caseSensitive =
+      input.caseSensitive ?? false;
+
+    if (
+      typeof caseSensitive !== "boolean"
+    ) {
+      throw new TypeError(
+        "caseSensitive must be a boolean."
+      );
+    }
+
+    const maxResults =
+      normalizeMaxResults(
+        input.maxResults
+      );
+
+    const {
+      root,
+      resolved,
+    } = resolveProjectPath(
+      context.projectRoot,
+      searchPath
+    );
+
+    let stats;
+
+    try {
+      stats = await fs.stat(
+        resolved
+      );
+    } catch (error) {
+  if (error?.code === "ENOENT") {
+    throw createToolError(
+      "path_not_found",
+      `Search path not found: ${searchPath}`
+    );
+  }
+
+  throw error;
+}
+
+    const results = [];
+
+    if (stats.isFile()) {
+      await searchFile({
+        filePath: resolved,
+        root,
+        query: input.query,
+        caseSensitive,
+        results,
+        maxResults,
+      });
+    } else if (stats.isDirectory()) {
+      await walk({
+        directory: resolved,
+        root,
+        query: input.query,
+        caseSensitive,
+        results,
+        maxResults,
+      });
+    } else {
+      throw createToolError(
+  "invalid_search_path",
+  `Search path is not a file or directory: ${searchPath}`
+);
+    }
+
+    return {
+      query: input.query,
+      path: searchPath,
+      caseSensitive,
+      matches: results,
+      count: results.length,
+      truncated:
+        results.length >= maxResults,
+    };
+  },
+});

package/packages/tools/shell.js

@@ -0,0 +1,352 @@
+import {
+  spawn,
+} from "node:child_process";
+
+import {
+  defineTool,
+} from "../core/tool.js";
+
+function createShellError(
+  code,
+  message,
+  details = null
+) {
+  const error =
+    new Error(message);
+
+  error.code = code;
+
+  if (details !== null) {
+    error.details = details;
+  }
+
+  return error;
+}
+
+/**
+ * Execute a command in the project.
+ *
+ * Approval/capability authorization belongs
+ * to the agent/tool execution layer.
+ *
+ * @param {object} options
+ * @param {string} options.command
+ * @param {string} [options.cwd]
+ * @param {number} [options.timeoutMs=120000]
+ * @param {number} [options.maxOutputBytes=200000]
+ * @returns {Promise<object>}
+ */
+export async function executeShell({
+  command,
+  cwd = process.cwd(),
+  timeoutMs = 120_000,
+  maxOutputBytes = 200_000,
+} = {}) {
+  if (
+    typeof command !== "string" ||
+    command.trim().length === 0
+  ) {
+    throw new TypeError(
+      "Shell command must be a non-empty string."
+    );
+  }
+
+  if (
+    typeof cwd !== "string" ||
+    cwd.trim().length === 0
+  ) {
+    throw new TypeError(
+      "Shell cwd must be a non-empty string."
+    );
+  }
+
+  if (
+    !Number.isFinite(timeoutMs) ||
+    timeoutMs <= 0
+  ) {
+    throw new TypeError(
+      "Shell timeoutMs must be a positive number."
+    );
+  }
+
+  if (
+    !Number.isFinite(maxOutputBytes) ||
+    maxOutputBytes <= 0
+  ) {
+    throw new TypeError(
+      "Shell maxOutputBytes must be a positive number."
+    );
+  }
+
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+
+    let stdoutTruncated = false;
+    let stderrTruncated = false;
+
+    let timedOut = false;
+    let settled = false;
+
+    const appendOutput = (
+      current,
+      chunk
+    ) => {
+      const text =
+        chunk.toString();
+
+      const next =
+        current + text;
+
+      if (
+        Buffer.byteLength(
+          next,
+          "utf8"
+        ) <= maxOutputBytes
+      ) {
+        return {
+          value: next,
+          truncated: false,
+        };
+      }
+
+      const buffer =
+        Buffer.from(
+          next,
+          "utf8"
+        );
+
+      return {
+        value:
+          buffer
+            .subarray(
+              0,
+              maxOutputBytes
+            )
+            .toString("utf8"),
+
+        truncated: true,
+      };
+    };
+
+    const child =
+      spawn(
+        command,
+        {
+          cwd,
+          shell: true,
+          windowsHide: true,
+
+          stdio: [
+            "ignore",
+            "pipe",
+            "pipe",
+          ],
+        }
+      );
+
+    const timer =
+      setTimeout(() => {
+        timedOut = true;
+
+        try {
+          child.kill();
+        } catch {
+          // Process may already have exited.
+        }
+      }, timeoutMs);
+
+    child.stdout.on(
+      "data",
+      (chunk) => {
+        const result =
+          appendOutput(
+            stdout,
+            chunk
+          );
+
+        stdout =
+          result.value;
+
+        stdoutTruncated =
+          stdoutTruncated ||
+          result.truncated;
+      }
+    );
+
+    child.stderr.on(
+      "data",
+      (chunk) => {
+        const result =
+          appendOutput(
+            stderr,
+            chunk
+          );
+
+        stderr =
+          result.value;
+
+        stderrTruncated =
+          stderrTruncated ||
+          result.truncated;
+      }
+    );
+
+    const finish = ({
+      code = null,
+      signal = null,
+      error = null,
+    } = {}) => {
+      if (settled) {
+        return;
+      }
+
+      settled = true;
+
+      clearTimeout(timer);
+
+      if (error) {
+        resolve({
+          success: false,
+
+          output: {
+            command,
+            cwd,
+            stdout,
+            stderr,
+            stdoutTruncated,
+            stderrTruncated,
+            exitCode: code,
+            signal,
+            timedOut,
+          },
+
+          error: {
+            code:
+              error?.code ??
+              "shell_execution_error",
+
+            message:
+              error?.message ??
+              "Shell execution failed.",
+          },
+        });
+
+        return;
+      }
+
+      resolve({
+        success:
+          !timedOut &&
+          code === 0,
+
+        output: {
+          command,
+          cwd,
+          stdout,
+          stderr,
+          stdoutTruncated,
+          stderrTruncated,
+          exitCode: code,
+          signal,
+          timedOut,
+        },
+      });
+    };
+
+    child.on(
+      "error",
+      (error) => {
+        finish({
+          error,
+        });
+      }
+    );
+
+    child.on(
+      "close",
+      (code, signal) => {
+        finish({
+          code,
+          signal,
+        });
+      }
+    );
+  });
+};
+
+/**
+ * CodeForge command-execution tool.
+ */
+export const shellTool =
+  defineTool({
+    name: "execute_command",
+
+    description:
+      "Execute a shell command in the current project. Use this to run tests, builds, scripts, git commands, or other project commands. Execution requires explicit user approval.",
+
+    source: "builtin",
+
+    capabilities: [
+      "process.execute",
+    ],
+
+    sideEffect: "execute",
+
+    approval: "always",
+
+    inputSchema: {
+      type: "object",
+
+      properties: {
+        command: {
+          type: "string",
+          minLength: 1,
+          description:
+            "Shell command to execute.",
+        },
+      },
+
+      required: [
+        "command",
+      ],
+
+      additionalProperties: false,
+    },
+
+    async execute(
+      input,
+      context = {}
+    ) {
+      const command =
+        input?.command;
+
+      if (
+        typeof command !== "string" ||
+        command.trim().length === 0
+      ) {
+        throw createShellError(
+          "invalid_command",
+          "Command must be a non-empty string."
+        );
+      }
+
+      const projectRoot =
+        context.projectRoot;
+
+      if (
+        typeof projectRoot !== "string" ||
+        projectRoot.trim().length === 0
+      ) {
+        throw createShellError(
+          "project_root_required",
+          "A project root is required for command execution."
+        );
+      }
+
+      return executeShell({
+        command,
+        cwd: projectRoot,
+      });
+    },
+  });