alchemy 2.0.0-beta.37 → 2.0.0-beta.39

package/src/Agent/util/ripgrep.ts

@@ -1,256 +0,0 @@
-// Ripgrep utility functions
-import { Schema } from "effect";
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as S from "effect/Schema";
-import * as Stream from "effect/Stream";
-import { ChildProcess } from "effect/unstable/process";
-import path from "path";
-import { exec } from "./exec.ts";
-
-// import { ZipReader, BlobReader, BlobWriter } from "@zip.js/zip.js";
-
-class Stats extends S.Class<Stats>("Stats")({
-  elapsed: S.Struct({
-    secs: S.Number,
-    nanos: S.Number,
-    human: S.String,
-  }),
-  searches: S.Number,
-  searches_with_match: S.Number,
-  bytes_searched: S.Number,
-  bytes_printed: S.Number,
-  matched_lines: S.Number,
-  matches: S.Number,
-}) {}
-
-class Begin extends S.Class<Begin>("Begin")({
-  type: S.Literal("begin"),
-  data: S.Struct({
-    path: S.Struct({
-      text: S.String,
-    }),
-  }),
-}) {}
-
-class Match extends S.Class<Match>("Match")({
-  type: S.Literal("match"),
-  data: S.Struct({
-    path: S.Struct({
-      text: S.String,
-    }),
-    lines: S.Struct({
-      text: S.String,
-    }),
-    line_number: S.Number,
-    absolute_offset: S.Number,
-    submatches: S.Array(
-      S.Struct({
-        match: S.Struct({
-          text: S.String,
-        }),
-        start: S.Number,
-        end: S.Number,
-      }),
-    ),
-  }),
-}) {}
-
-class End extends S.Class<End>("End")({
-  type: S.Literal("end"),
-  data: S.Struct({
-    path: S.Struct({
-      text: S.String,
-    }),
-    binary_offset: S.optional(S.Number),
-    stats: Stats,
-  }),
-}) {}
-
-class Summary extends S.Class<Summary>("Summary")({
-  type: S.Literal("summary"),
-  data: S.Struct({
-    elapsed_total: S.Struct({
-      human: S.String,
-      nanos: S.Number,
-      secs: S.Number,
-    }),
-    stats: Stats,
-  }),
-}) {}
-
-const Result = S.Union([Begin, Match, End, Summary]);
-
-const parseResult = Schema.decodeEffect(Result);
-
-export type Result = typeof Result.Type;
-
-export const findFiles = Effect.fn("findFiles")(function* (input: {
-  cwd: string;
-  glob?: string[];
-}) {
-  const fs = yield* FileSystem.FileSystem;
-  const stat = yield* fs.stat(input.cwd).pipe(Effect.catch(() => Effect.void));
-  if (!stat) {
-    return yield* Effect.fail(`No such file or directory: '${input.cwd}'`);
-  }
-  if (stat.type !== "Directory") {
-    return yield* Effect.fail(`Path is not a directory: '${input.cwd}'`);
-  }
-
-  const args = ["--files", "--follow", "--hidden", "--glob=!.git/*"];
-  if (input.glob) {
-    for (const g of input.glob) {
-      args.push(`--glob=${g}`);
-    }
-  }
-  const cmd = ChildProcess.make("rg", args);
-  const handle = yield* cmd;
-  const output = yield* Stream.mkString(Stream.decodeText(handle.stdout));
-  return output.trim().split(/\r?\n/).filter(Boolean);
-});
-
-export const tree = Effect.fn("tree")(function* (input: {
-  cwd: string;
-  limit?: number;
-}) {
-  const files = yield* findFiles({ cwd: input.cwd });
-  interface Node {
-    path: string[];
-    children: Node[];
-  }
-
-  function getPath(node: Node, parts: string[], create: boolean) {
-    if (parts.length === 0) return node;
-    let current = node;
-    for (const part of parts) {
-      let existing = current.children.find((x) => x.path.at(-1) === part);
-      if (!existing) {
-        if (!create) return;
-        existing = {
-          path: current.path.concat(part),
-          children: [],
-        };
-        current.children.push(existing);
-      }
-      current = existing;
-    }
-    return current;
-  }
-
-  const root: Node = {
-    path: [],
-    children: [],
-  };
-  for (const file of files) {
-    if (file.includes(".opencode")) continue;
-    const parts = file.split(path.sep);
-    getPath(root, parts, true);
-  }
-
-  function sort(node: Node) {
-    node.children.sort((a, b) => {
-      if (!a.children.length && b.children.length) return 1;
-      if (!b.children.length && a.children.length) return -1;
-      return a.path.at(-1)!.localeCompare(b.path.at(-1)!);
-    });
-    for (const child of node.children) {
-      sort(child);
-    }
-  }
-  sort(root);
-
-  let current = [root];
-  const result: Node = {
-    path: [],
-    children: [],
-  };
-
-  let processed = 0;
-  const limit = input.limit ?? 50;
-  while (current.length > 0) {
-    const next = [];
-    for (const node of current) {
-      if (node.children.length) next.push(...node.children);
-    }
-    const max = Math.max(...current.map((x) => x.children.length));
-    for (let i = 0; i < max && processed < limit; i++) {
-      for (const node of current) {
-        const child = node.children[i];
-        if (!child) continue;
-        getPath(result, child.path, true);
-        processed++;
-        if (processed >= limit) break;
-      }
-    }
-    if (processed >= limit) {
-      for (const node of [...current, ...next]) {
-        const compare = getPath(result, node.path, false);
-        if (!compare) continue;
-        if (compare?.children.length !== node.children.length) {
-          const diff = node.children.length - compare.children.length;
-          compare.children.push({
-            path: compare.path.concat(`[${diff} truncated]`),
-            children: [],
-          });
-        }
-      }
-      break;
-    }
-    current = next;
-  }
-
-  const lines: string[] = [];
-
-  function render(node: Node, depth: number) {
-    const indent = "\t".repeat(depth);
-    lines.push(indent + node.path.at(-1) + (node.children.length ? "/" : ""));
-    for (const child of node.children) {
-      render(child, depth + 1);
-    }
-  }
-  result.children.map((x) => render(x, 0));
-
-  return lines.join("\n");
-});
-
-export const search = Effect.fn("search")(function* (input: {
-  cwd: string;
-  pattern: string;
-  glob?: string[];
-  limit?: number;
-}) {
-  const args = ["rg", "--json", "--hidden", "--glob='!.git/*'"];
-
-  if (input.glob) {
-    for (const g of input.glob) {
-      args.push(`--glob=${g}`);
-    }
-  }
-
-  if (input.limit) {
-    args.push(`--max-count=${input.limit}`);
-  }
-
-  args.push("--");
-  args.push(input.pattern);
-
-  const result = yield* exec(
-    ChildProcess.make(args[0], args.slice(1), { shell: true }),
-  ).pipe(
-    Effect.catch(() => Effect.succeed({ exitCode: 0, stdout: "", stderr: "" })),
-  );
-
-  // const result = await $`${{ raw: command }}`.cwd(input.cwd).quiet().nothrow();
-  if (result.exitCode !== 0) {
-    return [];
-  }
-
-  // Handle both Unix (\n) and Windows (\r\n) line endings
-  const lines = result.stdout.trim().split(/\r?\n/).filter(Boolean);
-
-  // Parse JSON lines from ripgrep output
-  return (yield* Effect.all(lines.map((line) => parseResult(JSON.parse(line)))))
-    .filter((r) => r.type === "match")
-    .map((r) => r.data);
-});