@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-3egtvbgk.js

@@ -0,0 +1,253 @@
+import {
+  exports_mime
+} from "./ripgrep-dhphtf1x.js";
+import {
+  exports_filesystem
+} from "./ripgrep-jzf304yt.js";
+import {
+  exports_environment1 as exports_environment
+} from "./ripgrep-bfaw9j5x.js";
+import {
+  NonNegativeInt,
+  PositiveInt,
+  RelativePath
+} from "./ripgrep-j07kk359.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/tool/read-filesystem.ts
+var exports_read_filesystem = {};
+__export(exports_read_filesystem, {
+  read: () => read,
+  node: () => node,
+  TextPage: () => TextPage,
+  Service: () => Service,
+  ReadToolFileSystem: () => exports_read_filesystem,
+  PathKindError: () => PathKindError,
+  PageInput: () => PageInput,
+  OffsetOutOfRangeError: () => OffsetOutOfRangeError,
+  MediaIngestLimitError: () => MediaIngestLimitError,
+  MAX_READ_LINES: () => MAX_READ_LINES,
+  MAX_READ_BYTES: () => MAX_READ_BYTES,
+  MAX_MEDIA_INGEST_BYTES: () => MAX_MEDIA_INGEST_BYTES,
+  ListPage: () => ListPage,
+  ListEntry: () => ListEntry,
+  FileContent: () => FileContent,
+  BinaryFileError: () => BinaryFileError
+});
+import path from "path";
+import { pathToFileURL } from "url";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+import { lookup } from "mime-types";
+var MAX_READ_LINES = 2000;
+var MAX_READ_BYTES = 50 * 1024;
+var MAX_MEDIA_INGEST_BYTES = 20 * 1024 * 1024;
+var FIRST_CHUNK = 256 * 1024;
+var MAX_LINE_LENGTH = 2000;
+var MAX_LINE_SUFFIX = `... (line truncated to ${MAX_LINE_LENGTH} chars)`;
+var MEDIA_MIMES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp", "application/pdf"]);
+
+class BinaryFileError extends Schema.TaggedErrorClass()("ReadTool.BinaryFileError", {
+  resource: Schema.String
+}) {
+  get message() {
+    return `Cannot read binary file: ${this.resource}`;
+  }
+}
+
+class MediaIngestLimitError extends Schema.TaggedErrorClass()("ReadTool.MediaIngestLimitError", {
+  resource: Schema.String,
+  maximumBytes: Schema.Number
+}) {
+  get message() {
+    return `Media exceeds ${this.maximumBytes} byte ingestion limit: ${this.resource}`;
+  }
+}
+
+class OffsetOutOfRangeError extends Schema.TaggedErrorClass()("ReadTool.OffsetOutOfRangeError", { offset: Schema.Number }) {
+  get message() {
+    return `Offset ${this.offset} is out of range`;
+  }
+}
+
+class PathKindError extends Schema.TaggedErrorClass()("ReadTool.PathKindError", {
+  resource: Schema.String,
+  expected: Schema.Literals(["a file", "a file or directory"])
+}) {
+  get message() {
+    return `Path is not ${this.expected}: ${this.resource}`;
+  }
+}
+var PageInput = Schema.Struct({
+  offset: Schema.optionalKey(NonNegativeInt),
+  limit: Schema.optionalKey(NonNegativeInt.check(Schema.isLessThanOrEqualTo(MAX_READ_LINES)))
+});
+var FileContent = Schema.Struct({
+  type: Schema.Literal("file"),
+  ...exports_filesystem.Content.fields
+}).annotate({ identifier: "ReadTool.FileContent" });
+
+class TextPage extends Schema.Class("ReadTool.TextPage")({
+  type: Schema.Literal("text-page"),
+  content: Schema.String,
+  mime: Schema.String,
+  offset: PositiveInt,
+  truncated: Schema.Boolean,
+  next: Schema.optionalKey(PositiveInt)
+}) {
+}
+var ListEntry = Schema.Struct({
+  path: RelativePath,
+  type: Schema.Literals(["file", "directory", "symlink"])
+}).annotate({ identifier: "ReadTool.ListEntry" });
+
+class ListPage extends Schema.Class("ReadTool.ListPage")({
+  type: Schema.Literal("list-page"),
+  entries: Schema.Array(ListEntry),
+  truncated: Schema.Boolean,
+  next: Schema.optionalKey(PositiveInt)
+}) {
+}
+
+class Service extends Context.Service()("@opencode/ReadToolFileSystem") {
+}
+var mimeType = (value) => lookup(value) || "application/octet-stream";
+var read = Effect.fn("ReadTool.read")(function* (files, input, resource, page = {}) {
+  const first = yield* files.read(input, { offset: 0, length: FIRST_CHUNK }).pipe(Effect.catchTag("Environment.WrongKind", (error) => {
+    if (error.actual !== "directory")
+      return Effect.fail(new PathKindError({ resource, expected: "a file or directory" }));
+    return files.list(input).pipe(Effect.map((entries) => list(entries, page)), Effect.catchTag("Environment.WrongKind", () => Effect.fail(new PathKindError({ resource, expected: "a file or directory" }))));
+  }));
+  if (first instanceof ListPage)
+    return first;
+  const media = exports_mime.detect(first.bytes);
+  if (MEDIA_MIMES.has(media)) {
+    if (first.info.size > MAX_MEDIA_INGEST_BYTES)
+      return yield* new MediaIngestLimitError({ resource, maximumBytes: MAX_MEDIA_INGEST_BYTES });
+    const whole = yield* readFile(files, input, resource);
+    return {
+      type: "file",
+      uri: pathToFileURL(input).href,
+      name: path.basename(input),
+      content: Buffer.from(whole.bytes).toString("base64"),
+      encoding: "base64",
+      mime: media
+    };
+  }
+  const paged = first.info.size > MAX_READ_BYTES || page.offset !== undefined || page.limit !== undefined;
+  if (!paged) {
+    if (first.bytes.includes(0))
+      return yield* new BinaryFileError({ resource });
+    return {
+      type: "file",
+      uri: pathToFileURL(input).href,
+      name: path.basename(input),
+      content: new TextDecoder().decode(first.bytes),
+      encoding: "utf8",
+      mime: mimeType(input)
+    };
+  }
+  const chunks = [first.bytes];
+  while (true) {
+    const bytes = Buffer.concat(chunks);
+    const eof = bytes.length >= first.info.size;
+    const result = textPage(bytes, eof, page);
+    if (result !== undefined)
+      return yield* makeTextPage(bytes, input, resource, result);
+    const next = yield* readFile(files, input, resource, { offset: bytes.length, length: FIRST_CHUNK });
+    if (next.bytes.length === 0) {
+      const result2 = textPage(bytes, true, page);
+      if (result2 === undefined)
+        return yield* Effect.die("Read page did not settle at EOF");
+      return yield* makeTextPage(bytes, input, resource, result2);
+    }
+    chunks.push(next.bytes);
+  }
+});
+var readFile = (files, input, resource, range) => files.read(input, range).pipe(Effect.catchTag("Environment.WrongKind", () => Effect.fail(new PathKindError({ resource, expected: "a file" }))));
+var makeTextPage = Effect.fnUntraced(function* (bytes, input, resource, result) {
+  if (bytes.subarray(0, result.consumed).includes(0))
+    return yield* new BinaryFileError({ resource });
+  if (result.entries.length === 0 && result.offset !== 1)
+    return yield* new OffsetOutOfRangeError({ offset: result.offset });
+  return new TextPage({
+    type: "text-page",
+    content: result.entries.join(`
+`),
+    mime: mimeType(input),
+    offset: result.offset,
+    truncated: result.next !== undefined,
+    ...result.next === undefined ? {} : { next: result.next }
+  });
+});
+var list = (items, page) => {
+  const offset = page.offset || 1;
+  const limit = Math.min(page.limit || MAX_READ_LINES, MAX_READ_LINES);
+  const visible = items.flatMap((item) => item.type === "other" ? [] : [
+    ListEntry.make({
+      path: RelativePath.make(item.name + (item.type === "directory" ? path.sep : "")),
+      type: item.type
+    })
+  ]).sort((a, b) => a.type === "directory" ? b.type === "directory" ? a.path.localeCompare(b.path) : -1 : b.type === "directory" ? 1 : a.path.localeCompare(b.path));
+  const selected = visible.slice(offset - 1, offset - 1 + limit);
+  const truncated = offset - 1 + selected.length < visible.length;
+  return new ListPage({
+    type: "list-page",
+    entries: selected,
+    truncated,
+    ...truncated ? { next: offset + selected.length } : {}
+  });
+};
+var textPage = (bytes, eof, page) => {
+  const offset = page.offset || 1;
+  const limit = Math.min(page.limit || MAX_READ_LINES, MAX_READ_LINES);
+  const decoded = new TextDecoder().decode(bytes);
+  const split = decoded.split(`
+`);
+  const complete = eof ? split.at(-1) === "" ? split.slice(0, -1) : split : split.slice(0, -1);
+  const available = complete.map((line) => line.endsWith("\r") ? line.slice(0, -1) : line);
+  const entries = [];
+  let size = 0;
+  let next;
+  for (const [index, value] of available.slice(offset - 1).entries()) {
+    const line = offset + index;
+    if (entries.length >= limit || size >= MAX_READ_BYTES) {
+      next = line;
+      break;
+    }
+    const text = value.length > MAX_LINE_LENGTH ? value.slice(0, MAX_LINE_LENGTH) + MAX_LINE_SUFFIX : value;
+    const lineSize = Buffer.byteLength(text, "utf-8") + (entries.length > 0 ? 1 : 0);
+    if (size + lineSize > MAX_READ_BYTES) {
+      next = line;
+      break;
+    }
+    entries.push(text);
+    size += lineSize;
+  }
+  if (next === undefined && entries.length >= limit && (!eof || offset - 1 + entries.length < available.length))
+    next = offset + entries.length;
+  if (!eof && next === undefined)
+    return;
+  const consumedLines = next === undefined ? available.length : next - 1;
+  const consumed = consumedLines === 0 ? 0 : nthNewline(bytes, consumedLines) ?? bytes.length;
+  return { entries, offset, next, consumed };
+};
+var nthNewline = (bytes, count) => {
+  let found = 0;
+  for (const [index, byte] of bytes.entries()) {
+    if (byte !== 10)
+      continue;
+    found++;
+    if (found === count)
+      return index + 1;
+  }
+};
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const environment = yield* exports_environment.Service;
+  return Service.of({ read: (path2, resource, page) => read(environment.files, path2, resource, page) });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [exports_environment.node] });
+
+export { MAX_READ_LINES, MAX_READ_BYTES, MAX_MEDIA_INGEST_BYTES, BinaryFileError, MediaIngestLimitError, OffsetOutOfRangeError, PathKindError, PageInput, FileContent, TextPage, ListEntry, ListPage, Service, read, node, exports_read_filesystem };

package/dist/chunks/ripgrep-3g3rpp2x.js

@@ -0,0 +1,17 @@
+// src/database/migration/20260303231226_add_workspace_fields.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260303231226_add_workspace_fields",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`type\` text NOT NULL;`);
+      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`name\` text;`);
+      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`directory\` text;`);
+      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`extra\` text;`);
+      yield* tx.run(`ALTER TABLE \`workspace\` DROP COLUMN \`config\`;`);
+    });
+  }
+};
+var _20260303231226_add_workspace_fields_default = migration;
+
+export { _20260303231226_add_workspace_fields_default };

package/dist/chunks/ripgrep-3kbfazvv.js

@@ -0,0 +1,73 @@
+import {
+  fromRow
+} from "./ripgrep-m7j4gfae.js";
+import {
+  exports_history
+} from "./ripgrep-yndnp7z4.js";
+import {
+  exports_message
+} from "./ripgrep-25pxtba7.js";
+import {
+  SessionMessageTable,
+  SessionTable
+} from "./ripgrep-9d2xhdr4.js";
+import {
+  exports_database
+} from "./ripgrep-x7kx8910.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/session/store.ts
+var exports_store = {};
+__export(exports_store, {
+  node: () => node,
+  SessionStore: () => exports_store,
+  Service: () => Service
+});
+import { and, eq, isNotNull, isNull, sql } from "drizzle-orm";
+import { Context, Effect, Layer, Schema } from "effect";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { Session } from "@opencode-ai/schema/session";
+class Service extends Context.Service()("@opencode/SessionStore") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const { db } = yield* exports_database.Service;
+  const decodeMessage = Schema.decodeUnknownEffect(exports_message.Info);
+  return Service.of({
+    get: Effect.fn("SessionStore.get")(function* (sessionID) {
+      const row = yield* db.select().from(SessionTable).where(eq(SessionTable.id, sessionID)).get().pipe(Effect.orDie);
+      return row ? fromRow(row) : undefined;
+    }),
+    context: Effect.fn("SessionStore.context")(function* (sessionID) {
+      return yield* exports_history.load(db, sessionID);
+    }),
+    message: Effect.fn("SessionStore.message")(function* (messageID) {
+      const row = yield* db.select().from(SessionMessageTable).where(eq(SessionMessageTable.id, messageID)).get().pipe(Effect.orDie);
+      return row ? {
+        sessionID: Session.ID.make(row.session_id),
+        message: yield* decodeMessage({ ...row.data, id: row.id, type: row.type }).pipe(Effect.orDie)
+      } : undefined;
+    }),
+    listSuspended: Effect.fn("SessionStore.listSuspended")(function* () {
+      return yield* db.select({ sessionID: SessionTable.id }).from(SessionTable).where(and(isNotNull(SessionTable.time_suspended), isNull(SessionTable.parent_id))).all().pipe(Effect.orDie, Effect.map((rows) => rows.map((row) => row.sessionID)));
+    }),
+    claim: Effect.fn("SessionStore.claim")(function* (sessionID) {
+      yield* db.update(SessionTable).set({ time_suspended: Date.now(), time_updated: sql`${SessionTable.time_updated}` }).where(and(eq(SessionTable.id, sessionID), isNull(SessionTable.time_suspended))).run().pipe(Effect.orDie);
+    }),
+    release: Effect.fn("SessionStore.release")(function* (sessionID) {
+      yield* db.update(SessionTable).set({ time_suspended: null, resume_attempts: 0, time_updated: sql`${SessionTable.time_updated}` }).where(eq(SessionTable.id, sessionID)).run().pipe(Effect.orDie);
+    }),
+    releaseChildClaims: db.update(SessionTable).set({ time_suspended: null, resume_attempts: 0, time_updated: sql`${SessionTable.time_updated}` }).where(and(isNotNull(SessionTable.time_suspended), isNotNull(SessionTable.parent_id))).run().pipe(Effect.orDie, Effect.asVoid, Effect.withSpan("SessionStore.releaseChildClaims")),
+    countResume: Effect.fn("SessionStore.countResume")(function* (sessionID) {
+      const row = yield* db.update(SessionTable).set({
+        resume_attempts: sql`${SessionTable.resume_attempts} + 1`,
+        time_updated: sql`${SessionTable.time_updated}`
+      }).where(eq(SessionTable.id, sessionID)).returning({ attempts: SessionTable.resume_attempts }).get().pipe(Effect.orDie);
+      return row?.attempts;
+    })
+  });
+}));
+var node = makeGlobalNode({ service: Service, layer, deps: [exports_database.node] });
+
+export { Service, node, exports_store };

package/dist/chunks/ripgrep-3kxbn56b.js

@@ -0,0 +1,178 @@
+import {
+  RipgrepBinary
+} from "./ripgrep-h8ecejt5.js";
+import {
+  exports_environment1 as exports_environment
+} from "./ripgrep-bfaw9j5x.js";
+import {
+  NonNegativeInt,
+  PositiveInt,
+  RelativePath
+} from "./ripgrep-j07kk359.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/ripgrep.ts
+var exports_ripgrep = {};
+__export(exports_ripgrep, {
+  node: () => node,
+  Service: () => Service,
+  Ripgrep: () => exports_ripgrep,
+  InvalidPatternError: () => InvalidPatternError,
+  Error: () => Error
+});
+import { Context, Effect, Fiber, Layer, Schema, Stream } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { Entry, Match } from "@opencode-ai/schema/filesystem";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { collectStream, waitForAbort } from "@opencode-ai/util/process";
+var ERROR_BYTES = 8 * 1024;
+var MAX_SUBMATCHES = 100;
+var RawMatch = Schema.Struct({
+  type: Schema.Literal("match"),
+  data: Schema.Struct({
+    path: Schema.Struct({ text: Schema.String }),
+    lines: Schema.Struct({ text: Schema.String }),
+    line_number: PositiveInt,
+    absolute_offset: NonNegativeInt,
+    submatches: Schema.Array(Schema.Struct({
+      match: Schema.Struct({ text: Schema.String }),
+      start: NonNegativeInt,
+      end: NonNegativeInt
+    }))
+  })
+});
+var decodeJsonRecord = Schema.decodeUnknownEffect(Schema.UnknownFromJsonString);
+
+class Error extends Schema.TaggedErrorClass()("Ripgrep.Error", {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect())
+}) {
+}
+
+class InvalidPatternError extends Schema.TaggedErrorClass()("Ripgrep.InvalidPatternError", {
+  pattern: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class Service extends Context.Service()("@opencode/Ripgrep") {
+}
+var failure = (message, cause) => new Error({ message, cause });
+var isInvalidPattern = (stderr) => stderr.includes("regex parse error") || stderr.includes("error parsing regex");
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const environment = yield* exports_environment.Service;
+  const binary = yield* RipgrepBinary.Service;
+  const run = (input) => {
+    const program = Effect.scoped(Effect.gen(function* () {
+      const handle = yield* environment.spawner.spawn(ChildProcess.make(yield* binary.filepath, input.args, { cwd: input.cwd, extendEnv: true, stdin: "ignore" }));
+      const stderrFiber = yield* collectStream(handle.stderr, ERROR_BYTES).pipe(Effect.map((output) => output.buffer.toString("utf8")), Effect.forkScoped);
+      let observed = 0;
+      const rows = yield* Stream.decodeText(handle.stdout).pipe(Stream.splitLines, Stream.filter((line) => line.length > 0), Stream.mapEffect(input.parse), Stream.filter((row) => row !== undefined), Stream.tap((row) => {
+        if (!input.onItem || observed++ >= input.limit)
+          return Effect.void;
+        return input.onItem(row);
+      }), Stream.take(input.limit + 1), Stream.runCollect, Effect.map((chunk) => [...chunk]));
+      const truncated = rows.length > input.limit;
+      if (truncated)
+        return { items: rows.slice(0, input.limit), truncated, partial: false };
+      const code = yield* handle.exitCode;
+      const stderr = yield* Fiber.join(stderrFiber);
+      if (input.pattern && code === 2 && isInvalidPattern(stderr)) {
+        return yield* new InvalidPatternError({ pattern: input.pattern, message: stderr.trim() });
+      }
+      if (code !== 0 && code !== 1 && code !== 2) {
+        return yield* failure(stderr.trim() || `ripgrep failed with code ${code}`);
+      }
+      return { items: code === 1 ? [] : rows, truncated: false, partial: code === 2 };
+    }));
+    const abortable = input.signal ? program.pipe(Effect.raceFirst(waitForAbort(input.signal))) : program;
+    return abortable.pipe(Effect.mapError((cause) => cause instanceof Error || cause instanceof InvalidPatternError ? cause : failure("ripgrep execution failed", cause)));
+  };
+  return Service.of({
+    glob: (input) => run({
+      cwd: input.cwd,
+      limit: input.limit,
+      signal: input.signal,
+      args: [
+        "--no-config",
+        "--files",
+        ...input.hidden ? ["--hidden"] : [],
+        ...input.follow ? ["--follow"] : [],
+        `--glob=${input.pattern}`,
+        "--glob=!**/.git/**",
+        "."
+      ],
+      parse: (line) => Effect.succeed(line.replace(/^(?:\.[\\/])+/u, "").replace(/^[\\/]+/u, "").replaceAll("\\", "/"))
+    }).pipe(Effect.map((result) => result.items.map((relative) => Entry.make({
+      path: RelativePath.make(relative),
+      type: "file"
+    }))), Effect.catchTag("Ripgrep.InvalidPatternError", (cause) => Effect.fail(failure(cause.message, cause)))),
+    find: (input) => run({
+      cwd: input.cwd,
+      limit: input.limit,
+      signal: input.signal,
+      args: [
+        "--no-config",
+        "--files",
+        ...input.hidden ? ["--hidden"] : [],
+        ...input.follow ? ["--follow"] : [],
+        ...input.pattern === "*" ? [] : [`--glob=${input.pattern}`],
+        ...(input.exclude ?? []).map((pattern) => `--glob=!${pattern}`),
+        "--glob=!**/.git/**",
+        "."
+      ],
+      parse: (line) => {
+        const relative = line.replace(/^(?:\.[\\/])+/u, "").replace(/^[\\/]+/u, "").replaceAll("\\", "/");
+        return Effect.succeed(Entry.make({
+          path: RelativePath.make(relative),
+          type: "file"
+        }));
+      },
+      onItem: input.onEntry
+    }).pipe(Effect.map((result) => result.items), Effect.catchTag("Ripgrep.InvalidPatternError", (cause) => Effect.fail(failure(cause.message, cause)))),
+    grep: (input) => run({
+      ...input,
+      args: [
+        "--no-config",
+        "--json",
+        "--hidden",
+        "--no-messages",
+        ...input.include ? [`--glob=${input.include}`] : [],
+        "--glob=!**/.git/**",
+        "--",
+        input.pattern,
+        input.file ?? "."
+      ],
+      parse: (line) => decodeJsonRecord(line).pipe(Effect.mapError((cause) => failure("Invalid ripgrep JSON output", cause)), Effect.flatMap((json) => {
+        if (!json || typeof json !== "object" || !("type" in json) || json.type !== "match")
+          return Effect.succeed(undefined);
+        return Schema.decodeUnknownEffect(RawMatch)(json).pipe(Effect.map((match) => ({
+          ...match.data,
+          path: { text: match.data.path.text.replace(/^\.[\\/]/, "") },
+          submatches: match.data.submatches.slice(0, MAX_SUBMATCHES)
+        })), Effect.mapError((cause) => failure("Invalid ripgrep match output", cause)));
+      }))
+    }).pipe(Effect.map((result) => result.items.map((match) => {
+      const relative = match.path.text.replace(/^(?:\.[\\/])+/u, "").replace(/^[\\/]+/u, "").replaceAll("\\", "/");
+      return Match.make({
+        entry: Entry.make({
+          path: RelativePath.make(relative),
+          type: "file"
+        }),
+        line: match.line_number,
+        offset: match.absolute_offset,
+        text: match.lines.text.length > 2000 ? match.lines.text.slice(0, 2000) + "..." : match.lines.text,
+        submatches: match.submatches.map((submatch) => ({
+          text: submatch.match.text,
+          start: submatch.start,
+          end: submatch.end
+        }))
+      });
+    })))
+  });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [exports_environment.node, RipgrepBinary.node] });
+
+export { Error, InvalidPatternError, Service, node, exports_ripgrep };