@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-b4t9dkb3.js

@@ -0,0 +1,145 @@
+import {
+  exports_location_mutation
+} from "./ripgrep-0vcm5yws.js";
+import {
+  exports_filesystem
+} from "./ripgrep-jzf304yt.js";
+import {
+  exports_ripgrep
+} from "./ripgrep-3kxbn56b.js";
+import {
+  exports_environment1 as exports_environment
+} from "./ripgrep-bfaw9j5x.js";
+import {
+  exports_permission
+} from "./ripgrep-x5r76fqd.js";
+import {
+  exports_location
+} from "./ripgrep-hcyadm03.js";
+import {
+  RelativePath
+} from "./ripgrep-j07kk359.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/tool/plugin/grep.ts
+var exports_grep = {};
+__export(exports_grep, {
+  toModelContent: () => toModelContent,
+  name: () => name,
+  Plugin: () => Plugin,
+  Output: () => Output,
+  Input: () => Input,
+  GrepTool: () => exports_grep
+});
+import { ToolFailure } from "@opencode-ai/ai";
+import { Effect, Schema } from "effect";
+import path from "path";
+var name = "grep";
+var Input = Schema.Struct({
+  pattern: exports_filesystem.GrepInput.fields.pattern.check(Schema.isMinLength(1, { message: "Pattern must not be empty" })).annotate({
+    description: "Regular expression to search for in file contents (ripgrep syntax)"
+  }),
+  path: Schema.optionalKey(RelativePath).annotate({
+    description: "File or directory to search. Defaults to the current working directory."
+  }),
+  include: exports_filesystem.GrepInput.fields.include.annotate({
+    description: 'Glob pattern to filter files (for example, "*.js" or "*.{ts,tsx}")'
+  }),
+  limit: exports_filesystem.GrepInput.fields.limit.annotate({
+    description: `Maximum number of matching lines to return (default: ${exports_filesystem.DEFAULT_SEARCH_LIMIT})`
+  })
+});
+var Output = Schema.Array(exports_filesystem.Match);
+var toModelContent = (matches, truncated = false) => {
+  const lines = matches.length === 0 ? ["No matches found"] : [`Found ${matches.length} matches`];
+  let current = "";
+  for (const match of matches) {
+    if (current !== match.entry.path) {
+      if (current)
+        lines.push("");
+      current = match.entry.path;
+      lines.push(`${match.entry.path}:`);
+    }
+    lines.push(`  Line ${match.line}: ${match.text}`);
+  }
+  if (truncated)
+    lines.push("", `(Results are truncated: showing first ${matches.length} results. Consider using a more specific path or pattern.)`);
+  return lines.join(`
+`);
+};
+var Plugin = {
+  id: "opencode.tool.grep",
+  effect: Effect.fn("GrepTool.Plugin")(function* (ctx) {
+    const environment = yield* exports_environment.Service;
+    const ripgrep = yield* exports_ripgrep.Service;
+    const location = yield* exports_location.Service;
+    const mutation = yield* exports_location_mutation.Service;
+    const permission = yield* exports_permission.Service;
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false },
+      description: "Search file contents using regular expressions. Use it to locate specific code, symbols, or text patterns, and narrow searches with `path` or `include`. Returns matching file paths, line numbers, and line previews.",
+      input: Input,
+      output: Output,
+      execute: (input, context) => Effect.gen(function* () {
+        const source = { type: "tool", messageID: context.messageID, id: context.id };
+        const target = yield* mutation.resolve({ path: input.path ?? "." });
+        if (target.externalDirectory)
+          yield* permission.assert({
+            ...exports_location_mutation.externalDirectoryPermission(target.externalDirectory),
+            sessionID: context.sessionID,
+            agent: context.agent,
+            source
+          });
+        yield* permission.assert({
+          action: name,
+          resources: [input.pattern],
+          save: ["*"],
+          metadata: {
+            root: ".",
+            path: input.path,
+            include: input.include,
+            limit: input.limit
+          },
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source
+        });
+        const root = target.absolute;
+        const type = yield* exports_environment.typeFollowing(environment.files, root).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new ToolFailure({ message: `Search path does not exist: ${input.path ?? "."}` }))));
+        const cwd = type === "directory" ? root : path.dirname(root);
+        const limit = input.limit ?? exports_filesystem.DEFAULT_SEARCH_LIMIT;
+        const matches = yield* ripgrep.grep({
+          cwd,
+          pattern: input.pattern,
+          file: type === "file" ? path.basename(root) : undefined,
+          include: input.include,
+          limit: limit + 1
+        }).pipe(Effect.timeoutOrElse({
+          duration: exports_filesystem.DEFAULT_SEARCH_TIMEOUT_MS,
+          orElse: () => Effect.fail(new ToolFailure({
+            message: `Search timed out after ${exports_filesystem.DEFAULT_SEARCH_TIMEOUT_MS / 1000} seconds. Consider using a more specific path or pattern.`
+          }))
+        }), Effect.map((result) => result.map((match) => exports_filesystem.Match.make({
+          ...match,
+          entry: exports_filesystem.Entry.make({
+            ...match.entry,
+            path: RelativePath.make(path.relative(location.directory, path.resolve(cwd, match.entry.path)))
+          })
+        }))));
+        return { matches: matches.slice(0, limit), truncated: matches.length > limit };
+      }).pipe(Effect.map((result) => ({
+        output: result.matches,
+        content: toModelContent(result.matches.map((match) => ({
+          ...match,
+          entry: { ...match.entry, path: path.resolve(location.directory, match.entry.path) }
+        })), result.truncated),
+        metadata: { matches: result.matches.length, truncated: result.truncated }
+      })), Effect.mapError((error) => error instanceof ToolFailure ? error : error instanceof exports_ripgrep.InvalidPatternError ? new ToolFailure({ message: `Invalid regex pattern: ${error.message}` }) : new ToolFailure({ message: `Unable to grep for ${input.pattern}`, error })))
+    })).pipe(Effect.orDie);
+  })
+};
+
+export { name, Input, Output, toModelContent, Plugin, exports_grep };

package/dist/chunks/ripgrep-bbqs2y60.js

@@ -0,0 +1,14 @@
+// src/github-copilot/chat/get-response-metadata.ts
+function getResponseMetadata({
+  id,
+  model,
+  created
+}) {
+  return {
+    id: id ?? undefined,
+    modelId: model ?? undefined,
+    timestamp: created != null ? new Date(created * 1000) : undefined
+  };
+}
+
+export { getResponseMetadata };

package/dist/chunks/ripgrep-bfaw9j5x.js

@@ -0,0 +1,74 @@
+import {
+  makeLocalDriver
+} from "./ripgrep-5sgbvx3z.js";
+import {
+  execDefaults
+} from "./ripgrep-5pfeh60c.js";
+import {
+  makeMemoryDriver
+} from "./ripgrep-ed4jjjcc.js";
+import {
+  Failed,
+  NotFound,
+  WrongKind,
+  typeFollowing
+} from "./ripgrep-zthe9zqc.js";
+import {
+  exports_workspace
+} from "./ripgrep-q6a2s21x.js";
+import {
+  exports_location
+} from "./ripgrep-hcyadm03.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/environment/environment.ts
+var exports_environment2 = {};
+__export(exports_environment2, {
+  node: () => node,
+  Service: () => Service,
+  EnvironmentService: () => exports_environment2
+});
+import { CrossSpawnSpawner } from "@opencode-ai/util/cross-spawn-spawner";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer } from "effect";
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+
+// src/environment/index.ts
+var exports_environment = {};
+__export(exports_environment, {
+  typeFollowing: () => typeFollowing,
+  node: () => node,
+  makeMemoryDriver: () => makeMemoryDriver,
+  makeLocalDriver: () => makeLocalDriver,
+  makeFiles: () => makeFiles,
+  execDefaults: () => execDefaults,
+  WrongKind: () => WrongKind,
+  Service: () => Service,
+  NotFound: () => NotFound,
+  Failed: () => Failed,
+  Environment: () => exports_environment
+});
+var makeFiles = (driver) => ({
+  ...execDefaults(driver.spawner),
+  ...driver.overrides
+});
+
+// src/environment/environment.ts
+class Service extends Context.Service()("@opencode/Environment") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const spawner = yield* ChildProcessSpawner;
+  const location = yield* exports_location.Service;
+  const workspace = yield* exports_workspace.Service;
+  const driver = location.workspaceID ? yield* workspace.connect(location.workspaceID).pipe(Effect.mapError((cause) => new Error(`Failed to bind Environment to workspace ${location.workspaceID}`, { cause })), Effect.orDie) : makeLocalDriver(spawner);
+  return Service.of({ files: makeFiles(driver), spawner: driver.spawner });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [CrossSpawnSpawner.node, exports_location.node, exports_workspace.node]
+});
+
+export { Service, node, exports_environment2 as exports_environment, makeFiles, exports_environment as exports_environment1 };

package/dist/chunks/ripgrep-bhzwd3s3.js

@@ -0,0 +1,220 @@
+import {
+  exports_location_watcher
+} from "./ripgrep-3cwtqanj.js";
+import {
+  exports_llm
+} from "./ripgrep-rjdz2z4g.js";
+import {
+  exports_compaction
+} from "./ripgrep-wydmvyx8.js";
+import {
+  exports_generate_node
+} from "./ripgrep-bsphrc86.js";
+import {
+  exports_builtins
+} from "./ripgrep-hdh8wb4y.js";
+import {
+  exports_instructions as exports_instructions3
+} from "./ripgrep-maw26xhb.js";
+import {
+  exports_instructions as exports_instructions2
+} from "./ripgrep-naktqcjg.js";
+import {
+  exports_supervisor
+} from "./ripgrep-a6wxg7ch.js";
+import {
+  exports_mcp as exports_mcp2
+} from "./ripgrep-j4g5a3vz.js";
+import {
+  exports_read_filesystem
+} from "./ripgrep-3egtvbgk.js";
+import {
+  exports_instruction_entry
+} from "./ripgrep-r4h6gatx.js";
+import {
+  exports_title
+} from "./ripgrep-vp34t77k.js";
+import {
+  exports_instructions
+} from "./ripgrep-nc4xvjvt.js";
+import {
+  exports_vcs
+} from "./ripgrep-9pthdmc4.js";
+import {
+  exports_worktree
+} from "./ripgrep-07vebpv5.js";
+import {
+  exports_location_mutation
+} from "./ripgrep-0vcm5yws.js";
+import {
+  exports_generate
+} from "./ripgrep-e9cv6kbt.js";
+import {
+  exports_plugin
+} from "./ripgrep-vee0pxvg.js";
+import {
+  exports_websearch
+} from "./ripgrep-tsmrmbvn.js";
+import {
+  exports_tool
+} from "./ripgrep-dxqw5jns.js";
+import {
+  exports_model_transport
+} from "./ripgrep-42q4drvy.js";
+import {
+  exports_model
+} from "./ripgrep-h90v6ecj.js";
+import {
+  exports_snapshot
+} from "./ripgrep-6q3rd30y.js";
+import {
+  exports_reference
+} from "./ripgrep-77qdnkw9.js";
+import {
+  exports_location_service_map
+} from "./ripgrep-zdkg1k91.js";
+import {
+  exports_formatter
+} from "./ripgrep-qvqgqyrp.js";
+import {
+  exports_image
+} from "./ripgrep-09h352js.js";
+import {
+  exports_filesystem,
+  exports_search
+} from "./ripgrep-jzf304yt.js";
+import {
+  exports_pty
+} from "./ripgrep-w5d5n64x.js";
+import {
+  exports_instruction_discovery
+} from "./ripgrep-8rhqsgy6.js";
+import {
+  exports_shell
+} from "./ripgrep-93d188hz.js";
+import {
+  exports_tool_output
+} from "./ripgrep-szwg0y7q.js";
+import {
+  exports_command
+} from "./ripgrep-mz3jaqv3.js";
+import {
+  exports_mcp
+} from "./ripgrep-f37844cq.js";
+import {
+  exports_config
+} from "./ripgrep-rz9mfttk.js";
+import {
+  exports_file_mutation
+} from "./ripgrep-s87vpmv3.js";
+import {
+  exports_environment1 as exports_environment
+} from "./ripgrep-bfaw9j5x.js";
+import {
+  exports_skill
+} from "./ripgrep-p5bd5gkc.js";
+import {
+  exports_permission
+} from "./ripgrep-x5r76fqd.js";
+import {
+  exports_agent
+} from "./ripgrep-4ffc1teg.js";
+import {
+  exports_location
+} from "./ripgrep-hcyadm03.js";
+import {
+  AbsolutePath
+} from "./ripgrep-j07kk359.js";
+import {
+  exports_model_resolver
+} from "./ripgrep-3vs6bz0f.js";
+import {
+  exports_aisdk
+} from "./ripgrep-wqhtb879.js";
+import {
+  exports_catalog
+} from "./ripgrep-1cxcv3mr.js";
+import {
+  exports_integration
+} from "./ripgrep-qrmb8ve0.js";
+import {
+  exports_form
+} from "./ripgrep-75tpgmct.js";
+
+// src/location-services.ts
+import { Effect, Layer, LayerMap } from "effect";
+import path from "path";
+import { LayerNode } from "@opencode-ai/util/effect/layer-node";
+import { Node } from "@opencode-ai/util/effect/app-node";
+var locationServiceNodes = [
+  exports_location.node,
+  exports_environment.node,
+  exports_config.node,
+  exports_agent.node,
+  exports_command.node,
+  exports_reference.node,
+  exports_websearch.node,
+  exports_integration.node,
+  exports_catalog.node,
+  exports_model_resolver.node,
+  exports_aisdk.node,
+  exports_plugin.node,
+  exports_supervisor.node,
+  exports_worktree.refreshNode,
+  exports_search.node,
+  exports_filesystem.node,
+  exports_pty.node,
+  exports_shell.node,
+  exports_skill.node,
+  exports_builtins.node,
+  exports_instruction_discovery.node,
+  exports_location_mutation.node,
+  exports_file_mutation.node,
+  exports_formatter.node,
+  exports_mcp.node,
+  exports_permission.node,
+  exports_tool.node,
+  exports_tool_output.node,
+  exports_image.node,
+  exports_instructions3.node,
+  exports_instructions2.node,
+  exports_instruction_entry.node,
+  exports_form.node,
+  exports_generate.node,
+  exports_generate_node.node,
+  exports_read_filesystem.node,
+  exports_mcp2.node,
+  exports_instructions.node,
+  exports_model.node,
+  exports_model_transport.node,
+  exports_compaction.node,
+  exports_title.node,
+  exports_snapshot.node,
+  exports_llm.node,
+  exports_vcs.node,
+  exports_location_watcher.node
+];
+var locationServices = LayerNode.group(locationServiceNodes);
+function buildLocationServiceMap(replacements = []) {
+  const canonical = (ref) => exports_location.Ref.make({
+    directory: AbsolutePath.make(process.platform === "win32" ? path.normalize(ref.directory) : ref.directory),
+    workspaceID: ref.workspaceID
+  });
+  return Layer.effect(exports_location_service_map.Service, Effect.map(LayerMap.make((ref) => {
+    const startedAt = performance.now();
+    const allReplacements = replacements.concat([[exports_location.node, exports_location.boundNode(ref)]]);
+    const location = LayerNode.hoist(locationServices, Node.tags.values.global, allReplacements);
+    return LayerNode.compile(location.node).pipe(Layer.fresh, Layer.tap(() => Effect.logInfo("location services booted", {
+      directory: ref.directory,
+      workspaceID: ref.workspaceID,
+      durationMs: Math.round(performance.now() - startedAt)
+    })), Layer.provide(LayerNode.compile(location.hoisted)));
+  }, { idleTimeToLive: "60 minutes" }), (inner) => ({
+    ...inner,
+    get: (ref) => inner.get(canonical(ref)),
+    contextEffect: (ref) => inner.contextEffect(canonical(ref)),
+    invalidate: (ref) => inner.invalidate(canonical(ref))
+  })));
+}
+
+export { locationServices, buildLocationServiceMap };

package/dist/chunks/ripgrep-bqtt5yh9.js

@@ -0,0 +1,70 @@
+import {
+  PermissionTable
+} from "./ripgrep-nesb2rcz.js";
+import {
+  exports_project
+} from "./ripgrep-33amzv6f.js";
+import {
+  exports_database
+} from "./ripgrep-x7kx8910.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/permission/saved.ts
+var exports_saved = {};
+__export(exports_saved, {
+  node: () => node,
+  Service: () => Service,
+  PermissionSaved: () => exports_saved,
+  ListInput: () => ListInput,
+  Info: () => Info,
+  ID: () => ID,
+  AddInput: () => AddInput
+});
+import { eq } from "drizzle-orm";
+import { Context, Effect, Layer, Schema } from "effect";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { PermissionSaved } from "@opencode-ai/schema/permission-saved";
+var ID = PermissionSaved.ID;
+var Info = PermissionSaved.Info;
+var ListInput = Schema.Struct({
+  projectID: exports_project.ID.pipe(Schema.optional)
+}).annotate({ identifier: "PermissionSaved.ListInput" });
+var AddInput = Schema.Struct({
+  projectID: exports_project.ID,
+  action: Schema.String,
+  resources: Schema.Array(Schema.String)
+}).annotate({ identifier: "PermissionSaved.AddInput" });
+
+class Service extends Context.Service()("@opencode/PermissionSaved") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const { db } = yield* exports_database.Service;
+  const list = Effect.fn("PermissionSaved.list")(function* (input) {
+    const rows = yield* db.select().from(PermissionTable).where(input?.projectID ? eq(PermissionTable.project_id, input.projectID) : undefined).all().pipe(Effect.orDie);
+    return rows.map((row) => ({
+      id: row.id,
+      projectID: row.project_id,
+      action: row.action,
+      resource: row.resource
+    }));
+  });
+  const add = Effect.fn("PermissionSaved.add")(function* (input) {
+    if (!input.resources.length)
+      return;
+    yield* db.insert(PermissionTable).values(input.resources.map((resource) => ({
+      id: ID.create(),
+      project_id: input.projectID,
+      action: input.action,
+      resource
+    }))).onConflictDoNothing().run().pipe(Effect.orDie);
+  });
+  const remove = Effect.fn("PermissionSaved.remove")(function* (id) {
+    yield* db.delete(PermissionTable).where(eq(PermissionTable.id, id)).run().pipe(Effect.orDie);
+  });
+  return Service.of({ list, add, remove });
+}));
+var node = makeGlobalNode({ service: Service, layer, deps: [exports_database.node] });
+
+export { ID, Info, ListInput, AddInput, Service, node, exports_saved };

package/dist/chunks/ripgrep-brsh5f65.js

@@ -0,0 +1,146 @@
+// src/github-copilot/chat/convert-to-openai-compatible-chat-messages.ts
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
+import { convertToBase64 } from "@ai-sdk/provider-utils";
+function getOpenAIMetadata(message) {
+  return message?.providerOptions?.copilot ?? {};
+}
+function convertToOpenAICompatibleChatMessages(prompt) {
+  const messages = [];
+  for (const { role, content, ...message } of prompt) {
+    const metadata = getOpenAIMetadata({ ...message });
+    switch (role) {
+      case "system": {
+        messages.push({
+          role: "system",
+          content,
+          ...metadata
+        });
+        break;
+      }
+      case "user": {
+        if (content.length === 1 && content[0].type === "text") {
+          messages.push({
+            role: "user",
+            content: content[0].text,
+            ...getOpenAIMetadata(content[0])
+          });
+          break;
+        }
+        messages.push({
+          role: "user",
+          content: content.map((part) => {
+            const partMetadata = getOpenAIMetadata(part);
+            switch (part.type) {
+              case "text": {
+                return { type: "text", text: part.text, ...partMetadata };
+              }
+              case "file": {
+                if (part.mediaType.startsWith("image/")) {
+                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+                  return {
+                    type: "image_url",
+                    image_url: {
+                      url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${convertToBase64(part.data)}`
+                    },
+                    ...partMetadata
+                  };
+                } else {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: `file part media type ${part.mediaType}`
+                  });
+                }
+              }
+            }
+          }),
+          ...metadata
+        });
+        break;
+      }
+      case "assistant": {
+        let text = "";
+        let reasoningText;
+        let reasoningOpaque;
+        const toolCalls = [];
+        for (const part of content) {
+          const partMetadata = getOpenAIMetadata(part);
+          const partOpaque = part.providerOptions?.copilot?.reasoningOpaque;
+          if (partOpaque && !reasoningOpaque) {
+            reasoningOpaque = partOpaque;
+          }
+          switch (part.type) {
+            case "text": {
+              text += part.text;
+              break;
+            }
+            case "reasoning": {
+              if (part.text)
+                reasoningText = part.text;
+              break;
+            }
+            case "tool-call": {
+              toolCalls.push({
+                id: part.toolCallId,
+                type: "function",
+                function: {
+                  name: part.toolName,
+                  arguments: JSON.stringify(part.input)
+                },
+                ...partMetadata
+              });
+              break;
+            }
+          }
+        }
+        messages.push({
+          role: "assistant",
+          content: text || null,
+          tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+          reasoning_text: reasoningOpaque ? reasoningText : undefined,
+          reasoning_opaque: reasoningOpaque,
+          ...metadata
+        });
+        break;
+      }
+      case "tool": {
+        for (const toolResponse of content) {
+          if (toolResponse.type === "tool-approval-response") {
+            continue;
+          }
+          const output = toolResponse.output;
+          let contentValue;
+          switch (output.type) {
+            case "text":
+            case "error-text":
+              contentValue = output.value;
+              break;
+            case "execution-denied":
+              contentValue = output.reason ?? "Tool execution denied.";
+              break;
+            case "content":
+            case "json":
+            case "error-json":
+              contentValue = JSON.stringify(output.value);
+              break;
+          }
+          const toolResponseMetadata = getOpenAIMetadata(toolResponse);
+          messages.push({
+            role: "tool",
+            tool_call_id: toolResponse.toolCallId,
+            content: contentValue,
+            ...toolResponseMetadata
+          });
+        }
+        break;
+      }
+      default: {
+        const _exhaustiveCheck = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  return messages;
+}
+
+export { convertToOpenAICompatibleChatMessages };