@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-57ntp81p.js

@@ -0,0 +1,42 @@
+import {
+  exports_project
+} from "./location-mutation-sbx2darh.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/location.ts
+var exports_location = {};
+__export(exports_location, {
+  response: () => response,
+  node: () => node,
+  boundNode: () => boundNode,
+  Service: () => Service,
+  Ref: () => Ref,
+  Location: () => exports_location,
+  Info: () => Info
+});
+import { Context, Effect, Layer } from "effect";
+import { Info, Ref, response } from "@opencode-ai/schema/location";
+import { LayerNode } from "@opencode-ai/util/effect/layer-node";
+import { makeLocationNode, tags } from "@opencode-ai/util/effect/app-node";
+class Service extends Context.Service()("@opencode/Location") {
+}
+var node = LayerNode.unbound(Service, tags.values.location);
+var layer = (ref) => Layer.effect(Service, Effect.gen(function* () {
+  const project = yield* exports_project.Service;
+  const resolved = yield* project.resolve(ref.directory);
+  return Service.of({
+    directory: ref.directory,
+    workspaceID: ref.workspaceID,
+    project: { id: resolved.id, directory: resolved.directory, canonical: resolved.canonical },
+    vcs: resolved.vcs
+  });
+}));
+var boundNode = (ref) => makeLocationNode({
+  service: Service,
+  layer: layer(ref),
+  deps: [exports_project.node]
+});
+
+export { Info, Ref, response, Service, node, boundNode, exports_location };

package/dist/chunks/location-mutation-57ny1p8n.js

@@ -0,0 +1,73 @@
+import {
+  exports_model
+} from "./location-mutation-0mqwymb3.js";
+import {
+  exports_permission
+} from "./location-mutation-gjaba53s.js";
+import {
+  AgentNotFoundError,
+  StepFailedError,
+  UserInterruptedError
+} from "./location-mutation-s6by3cc4.js";
+import {
+  exports_integration
+} from "./location-mutation-67ww7a6n.js";
+
+// src/session/to-session-error.ts
+import { AIError, ToolFailure } from "@opencode-ai/ai";
+import { Tool } from "@opencode-ai/schema/tool";
+function toSessionError(cause) {
+  if (cause instanceof AIError) {
+    switch (cause.reason._tag) {
+      case "RateLimit":
+        return providerError("provider.rate-limit", cause.reason);
+      case "Authentication":
+        return providerError("provider.auth", cause.reason);
+      case "QuotaExceeded":
+        return providerError("provider.quota", cause.reason);
+      case "ContentPolicy":
+        return providerError("provider.content-filter", cause.reason);
+      case "Transport":
+        return providerError("provider.transport", cause.reason);
+      case "ProviderInternal":
+        return providerError("provider.internal", cause.reason);
+      case "InvalidProviderOutput":
+        return providerError("provider.invalid-output", cause.reason);
+      case "InvalidRequest":
+        return providerError("provider.invalid-request", cause.reason);
+      case "NoRoute":
+        return providerError("provider.no-route", cause.reason);
+      case "UnknownProvider":
+        return providerError("provider.unknown", cause.reason);
+      default: {
+        const exhaustive = cause.reason;
+        return exhaustive;
+      }
+    }
+  }
+  if (cause instanceof exports_permission.BlockedError)
+    return { type: "permission.rejected", message: cause.message };
+  if (cause instanceof ToolFailure || cause instanceof Tool.Error) {
+    if (cause.error === undefined)
+      return { type: "tool.execution", message: cause.message };
+    const unwrapped = toSessionError(cause.error);
+    return unwrapped.message === "" ? { ...unwrapped, type: "tool.execution", message: cause.message } : unwrapped;
+  }
+  if (cause instanceof StepFailedError)
+    return cause.error;
+  if (cause instanceof AgentNotFoundError)
+    return { type: "unknown", message: cause.message };
+  if (cause instanceof UserInterruptedError)
+    return { type: "aborted", message: cause.message };
+  if (cause instanceof exports_model.ModelNotSelectedError || cause instanceof exports_model.ModelUnavailableError || cause instanceof exports_model.VariantUnavailableError || cause instanceof exports_model.UnsupportedPackageError || cause instanceof exports_model.UnresolvedProviderVariablesError)
+    return { type: "provider.no-route", message: cause.message };
+  if (cause instanceof exports_integration.AuthorizationError)
+    return { type: "provider.auth", message: cause.message };
+  return { type: "unknown", message: cause instanceof Error ? cause.message : String(cause) };
+}
+function providerError(type, reason) {
+  const status = ("http" in reason ? reason.http?.response?.status : undefined) ?? ("status" in reason ? reason.status : undefined);
+  return { type, message: reason.message, ...status === undefined ? {} : { status } };
+}
+
+export { toSessionError };

package/dist/chunks/location-mutation-57tzwnz4.js

@@ -0,0 +1,107 @@
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/codemode/catalog.ts
+var exports_catalog = {};
+__export(exports_catalog, {
+  summarize: () => summarize,
+  Summary: () => Summary,
+  Entry: () => Entry,
+  CodeModeCatalog: () => exports_catalog
+});
+import { Schema } from "effect";
+var Entry = Schema.Struct({
+  path: Schema.String,
+  description: Schema.String,
+  signature: Schema.String,
+  pinned: Schema.optionalKey(Schema.Boolean)
+});
+var Listing = Schema.Struct({
+  path: Schema.String,
+  line: Schema.String
+});
+var Namespace = Schema.Struct({
+  name: Schema.String,
+  count: Schema.Number,
+  entries: Schema.Array(Listing)
+});
+var Summary = Schema.Struct({
+  total: Schema.Number,
+  shown: Schema.Number,
+  namespaces: Schema.Array(Namespace)
+});
+var DESCRIPTION_LIMIT = 120;
+var CHARACTERS_PER_TOKEN = 4;
+var INLINE_BUDGET = 2000;
+function summarize(entries, budget = INLINE_BUDGET) {
+  const namespaces = [...Map.groupBy(entries, (entry) => entry.path.split(".", 1)[0] ?? entry.path)].sort(([left], [right]) => {
+    if (left < right)
+      return -1;
+    if (left > right)
+      return 1;
+    return 0;
+  }).map(([name, namespaceEntries]) => {
+    const listings = namespaceEntries.map((entry) => {
+      const firstLine = entry.description.split(`
+`, 1)[0]?.trim() ?? "";
+      const description = firstLine.length > DESCRIPTION_LIMIT ? firstLine.slice(0, DESCRIPTION_LIMIT - 3) + "..." : firstLine;
+      const suffix = description.length === 0 ? "" : ` // ${description}`;
+      return { path: entry.path, line: `  - ${entry.signature}${suffix}` };
+    }).toSorted((left, right) => {
+      if (left.path < right.path)
+        return -1;
+      if (left.path > right.path)
+        return 1;
+      return 0;
+    });
+    const ranked = rankListings(listings);
+    const pinned = new Set(namespaceEntries.filter((entry) => entry.pinned).map((entry) => listings.find((listing) => listing.path === entry.path)).filter((listing) => listing !== undefined));
+    return {
+      name,
+      listings,
+      selectionOrder: ranked.filter((candidate) => !pinned.has(candidate.listing)),
+      selectedListings: pinned,
+      selectionIndex: 0
+    };
+  });
+  const active = new Set(namespaces);
+  let remaining = budget - namespaces.flatMap((namespace) => namespace.listings.filter((listing) => namespace.selectedListings.has(listing))).reduce((total, listing) => total + Math.round(listing.line.length / CHARACTERS_PER_TOKEN), 0);
+  while (active.size > 0) {
+    for (const namespace of active) {
+      const candidate = namespace.selectionOrder[namespace.selectionIndex];
+      if (!candidate || candidate.cost > remaining) {
+        active.delete(namespace);
+        continue;
+      }
+      namespace.selectedListings.add(candidate.listing);
+      namespace.selectionIndex += 1;
+      remaining -= candidate.cost;
+      if (namespace.selectionIndex === namespace.selectionOrder.length)
+        active.delete(namespace);
+    }
+  }
+  const namespaceSummaries = namespaces.map((namespace) => ({
+    name: namespace.name,
+    count: namespace.listings.length,
+    entries: namespace.listings.filter((listing) => namespace.selectedListings.has(listing))
+  }));
+  return {
+    total: entries.length,
+    shown: namespaceSummaries.reduce((total, namespace) => total + namespace.entries.length, 0),
+    namespaces: namespaceSummaries
+  };
+}
+function rankListings(listings) {
+  return listings.map((listing) => ({ listing, cost: Math.round(listing.line.length / CHARACTERS_PER_TOKEN) })).toSorted((left, right) => {
+    if (left.cost !== right.cost)
+      return left.cost - right.cost;
+    if (left.listing.path < right.listing.path)
+      return -1;
+    if (left.listing.path > right.listing.path)
+      return 1;
+    return 0;
+  });
+}
+
+export { Entry, Summary, summarize, exports_catalog };

package/dist/chunks/location-mutation-5a5ch9ts.js

@@ -0,0 +1,31 @@
+// src/github-copilot/responses/tool/code-interpreter.ts
+import { createProviderToolFactoryWithOutputSchema } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+var codeInterpreterInputSchema = z.object({
+  code: z.string().nullish(),
+  containerId: z.string()
+});
+var codeInterpreterOutputSchema = z.object({
+  outputs: z.array(z.discriminatedUnion("type", [
+    z.object({ type: z.literal("logs"), logs: z.string() }),
+    z.object({ type: z.literal("image"), url: z.string() })
+  ])).nullish()
+});
+var codeInterpreterArgsSchema = z.object({
+  container: z.union([
+    z.string(),
+    z.object({
+      fileIds: z.array(z.string()).optional()
+    })
+  ]).optional()
+});
+var codeInterpreterToolFactory = createProviderToolFactoryWithOutputSchema({
+  id: "openai.code_interpreter",
+  inputSchema: codeInterpreterInputSchema,
+  outputSchema: codeInterpreterOutputSchema
+});
+var codeInterpreter = (args = {}) => {
+  return codeInterpreterToolFactory(args);
+};
+
+export { codeInterpreterInputSchema, codeInterpreterOutputSchema, codeInterpreterArgsSchema, codeInterpreterToolFactory, codeInterpreter };

package/dist/chunks/location-mutation-5bt5w96g.js

@@ -0,0 +1,145 @@
+import {
+  exports_permission
+} from "./location-mutation-gjaba53s.js";
+import {
+  exports_location_mutation
+} from "./location-mutation-z17t3kn2.js";
+import {
+  exports_filesystem
+} from "./location-mutation-mgwgz9qe.js";
+import {
+  exports_ripgrep
+} from "./location-mutation-afmh0nd1.js";
+import {
+  exports_environment1 as exports_environment
+} from "./location-mutation-pysc8t9c.js";
+import {
+  exports_location
+} from "./location-mutation-57ntp81p.js";
+import {
+  RelativePath
+} from "./location-mutation-j07kk359.js";
+import {
+  __export
+} from "./location-mutation-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/location-mutation-5fvy871a.js

@@ -0,0 +1,162 @@
+import {
+  exports_repository
+} from "./location-mutation-1kvtxahz.js";
+import {
+  exports_git
+} from "./location-mutation-kcwh27nh.js";
+import {
+  AbsolutePath
+} from "./location-mutation-j07kk359.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/repository-cache.ts
+var exports_repository_cache = {};
+__export(exports_repository_cache, {
+  validateBranch: () => validateBranch,
+  node: () => node,
+  isError: () => isError,
+  Service: () => Service,
+  ResetFailedError: () => ResetFailedError,
+  RepositoryCache: () => exports_repository_cache,
+  LockFailedError: () => LockFailedError,
+  InvalidBranchError: () => InvalidBranchError,
+  FetchFailedError: () => FetchFailedError,
+  CloneFailedError: () => CloneFailedError,
+  CheckoutFailedError: () => CheckoutFailedError,
+  CacheOperationError: () => CacheOperationError
+});
+import path from "path";
+import { Context, Effect, Layer, Schema } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Global } from "@opencode-ai/util/global";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { EffectFlock } from "@opencode-ai/util/effect-flock";
+
+class InvalidBranchError extends Schema.TaggedErrorClass()("RepositoryCacheInvalidBranchError", {
+  branch: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class CloneFailedError extends Schema.TaggedErrorClass()("RepositoryCacheCloneFailedError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class FetchFailedError extends Schema.TaggedErrorClass()("RepositoryCacheFetchFailedError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class CheckoutFailedError extends Schema.TaggedErrorClass()("RepositoryCacheCheckoutFailedError", {
+  repository: Schema.String,
+  branch: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class ResetFailedError extends Schema.TaggedErrorClass()("RepositoryCacheResetFailedError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class LockFailedError extends Schema.TaggedErrorClass()("RepositoryCacheLockFailedError", {
+  localPath: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class CacheOperationError extends Schema.TaggedErrorClass()("RepositoryCacheOperationError", {
+  operation: Schema.String,
+  path: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class Service extends Context.Service()("@opencode/RepositoryCache") {
+}
+function isError(error) {
+  return error instanceof InvalidBranchError || error instanceof CloneFailedError || error instanceof FetchFailedError || error instanceof CheckoutFailedError || error instanceof ResetFailedError || error instanceof LockFailedError || error instanceof CacheOperationError;
+}
+var validateBranch = Effect.fn("RepositoryCache.validateBranch")(function* (branch) {
+  return yield* Effect.try({
+    try: () => exports_repository.validateBranch(branch),
+    catch: (error) => new InvalidBranchError({ branch, message: errorMessage(error) })
+  });
+});
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const git = yield* exports_git.Service;
+  const flock = yield* EffectFlock.Service;
+  const global = yield* Global.Service;
+  return Service.of({
+    ensure: Effect.fn("RepositoryCache.ensure")(function* (input) {
+      if (input.branch)
+        yield* validateBranch(input.branch);
+      const repository = input.reference.label;
+      const localPath = exports_repository.cachePath(global.repos, input.reference, input.branch);
+      const cloneTarget = exports_repository.parse(input.reference.remote) ?? input.reference;
+      return yield* flock.withLock(Effect.gen(function* () {
+        yield* cacheOperation(fs.ensureDir(path.dirname(localPath)), "ensure cache directory", localPath);
+        const existing = yield* git.repo.discover(AbsolutePath.make(localPath));
+        const origin = existing ? yield* git.remote.get(existing) : undefined;
+        const originReference = origin ? exports_repository.parse(origin) : undefined;
+        const worktree = existing ? yield* fs.resolve(localPath) : undefined;
+        const reuse = Boolean(existing && existing.worktree === worktree && originReference && exports_repository.same(originReference, cloneTarget));
+        if (!reuse && (yield* fs.existsSafe(localPath))) {
+          yield* cacheOperation(fs.remove(localPath, { recursive: true }), "remove stale cache", localPath);
+        }
+        const status = !reuse ? "cloned" : input.refresh ? "refreshed" : "cached";
+        if (status === "cloned") {
+          yield* git.repo.clone({
+            remote: input.reference.remote,
+            directory: AbsolutePath.make(localPath),
+            branch: input.branch
+          }).pipe(Effect.mapError((error) => new CloneFailedError({ repository, message: error.message })));
+        }
+        if (status === "refreshed") {
+          if (!existing)
+            return yield* new FetchFailedError({ repository, message: "Repository is unavailable" });
+          yield* git.sync.fetchRemotes(existing).pipe(Effect.mapError((error) => new FetchFailedError({ repository, message: error.message })));
+          if (input.branch) {
+            yield* git.sync.fetchBranch(existing, { branch: input.branch }).pipe(Effect.mapError((error) => new FetchFailedError({ repository, message: error.message })));
+          }
+          const branch = input.branch ?? (yield* git.history.defaultRemoteBranch(existing));
+          if (branch) {
+            yield* git.sync.checkoutRemoteBranch(existing, { branch }).pipe(Effect.mapError((error) => new CheckoutFailedError({ repository, branch, message: error.message })));
+          }
+          const target = branch ?? (yield* git.history.branch(existing));
+          yield* git.sync.resetHard(existing, target ? `origin/${target}` : "HEAD").pipe(Effect.mapError((error) => new ResetFailedError({ repository, message: error.message })));
+        }
+        const checkout = yield* git.repo.discover(AbsolutePath.make(localPath));
+        return {
+          repository,
+          host: input.reference.host,
+          remote: input.reference.remote,
+          localPath,
+          status,
+          head: checkout ? yield* git.history.head(checkout) : undefined,
+          branch: checkout ? yield* git.history.branch(checkout) : undefined
+        };
+      }), `repository-cache:${localPath}`).pipe(Effect.mapError((error) => isError(error) ? error : new LockFailedError({ localPath, message: errorMessage(error) })));
+    })
+  });
+}));
+var node = makeGlobalNode({
+  service: Service,
+  layer,
+  deps: [EffectFlock.node, FSUtil.node, exports_git.node, Global.node]
+});
+function errorMessage(error) {
+  return error instanceof globalThis.Error ? error.message : String(error);
+}
+function cacheOperation(effect, operation, target) {
+  return effect.pipe(Effect.mapError((error) => new CacheOperationError({ operation, path: target, message: errorMessage(error) })));
+}
+
+export { InvalidBranchError, CloneFailedError, FetchFailedError, CheckoutFailedError, ResetFailedError, LockFailedError, CacheOperationError, Service, isError, validateBranch, node, exports_repository_cache };