@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-9e8kfd6p.js

@@ -0,0 +1,239 @@
+import {
+  Slug
+} from "./permission-df3v2q6j.js";
+import {
+  exports_bus
+} from "./permission-r5ce0emk.js";
+import {
+  exports_location
+} from "./permission-1e2ryyac.js";
+import {
+  exports_project
+} from "./permission-j2hktz7g.js";
+import {
+  exports_directories
+} from "./permission-at95jcnb.js";
+import {
+  exports_database
+} from "./permission-8w2n8x74.js";
+import {
+  exports_git
+} from "./permission-z66vzcey.js";
+import {
+  AbsolutePath
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/project/copy-strategies.ts
+import { Effect as Effect2 } from "effect";
+
+// src/project/copy.ts
+var exports_copy = {};
+__export(exports_copy, {
+  refreshNode: () => refreshNode,
+  refreshAfterBoot: () => refreshAfterBoot,
+  node: () => node,
+  StrategyUnavailableError: () => StrategyUnavailableError,
+  StrategyID: () => StrategyID,
+  SourceDirectoryNotFoundError: () => SourceDirectoryNotFoundError,
+  Service: () => Service,
+  RemoveInput: () => RemoveInput,
+  RefreshResult: () => RefreshResult,
+  RefreshInput: () => RefreshInput,
+  ProjectCopy: () => exports_copy,
+  ListEntry: () => ListEntry,
+  InvalidDirectoryError: () => InvalidDirectoryError,
+  Event: () => Event,
+  DirectoryUnavailableError: () => DirectoryUnavailableError,
+  DestinationExistsError: () => DestinationExistsError,
+  CreateInput: () => CreateInput,
+  Copy: () => Copy
+});
+import { Context, Effect, Layer, Schema } from "effect";
+import path from "path";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Event } from "@opencode-ai/schema/project-directories";
+import { ProjectCopy } from "@opencode-ai/schema/project-copy";
+var StrategyID = ProjectCopy.StrategyID;
+var CreateInput = ProjectCopy.CreateInput;
+var RemoveInput = ProjectCopy.RemoveInput;
+var RefreshInput = Schema.Struct({
+  projectID: exports_project.ID
+}).annotate({ identifier: "ProjectCopy.RefreshInput" });
+var RefreshResult = Schema.Struct({
+  updated: Schema.Array(AbsolutePath),
+  removed: Schema.Array(AbsolutePath)
+}).annotate({ identifier: "ProjectCopy.RefreshResult" });
+var Copy = ProjectCopy.Copy;
+var ListEntry = Schema.Struct({
+  directory: AbsolutePath,
+  type: Schema.Literals(["root", "copy"])
+}).annotate({ identifier: "ProjectCopy.ListEntry" });
+
+class SourceDirectoryNotFoundError extends Schema.TaggedErrorClass()("ProjectCopy.SourceDirectoryNotFoundError", { directory: AbsolutePath }) {
+}
+
+class DestinationExistsError extends Schema.TaggedErrorClass()("ProjectCopy.DestinationExistsError", { directory: AbsolutePath }) {
+}
+
+class DirectoryUnavailableError extends Schema.TaggedErrorClass()("ProjectCopy.DirectoryUnavailableError", { directory: AbsolutePath }) {
+}
+
+class InvalidDirectoryError extends Schema.TaggedErrorClass()("ProjectCopy.InvalidDirectoryError", { directory: AbsolutePath }) {
+}
+
+class StrategyUnavailableError extends Schema.TaggedErrorClass()("ProjectCopy.StrategyUnavailableError", { strategy: StrategyID }) {
+}
+class Service extends Context.Service()("@opencode/ProjectCopy") {
+}
+var refreshAfterBoot = Effect.gen(function* () {
+  const location = yield* exports_location.Service;
+  const copies = yield* Service;
+  yield* Effect.gen(function* () {
+    yield* Effect.logInfo("project copy refresh started", { projectID: location.project.id });
+    const result = yield* copies.refresh({ projectID: location.project.id });
+    yield* Effect.logInfo("project copy refresh done", {
+      projectID: location.project.id,
+      updated: result.updated,
+      removed: result.removed
+    });
+  }).pipe(Effect.catchCause((cause) => Effect.logWarning("project copy refresh failed", { cause })), Effect.forkScoped, Effect.asVoid);
+});
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const git = yield* exports_git.Service;
+  const directories = yield* exports_directories.Service;
+  const db = (yield* exports_database.Service).db;
+  const bus = yield* exports_bus.Service;
+  const changed = Effect.fnUntraced(function* (projectID, update) {
+    if (update)
+      yield* bus.publish(Event.Updated, { projectID });
+  });
+  const canonical = Effect.fnUntraced(function* (input) {
+    const resolved = AbsolutePath.make(yield* fs.resolve(input));
+    if (!(yield* fs.isDir(resolved)))
+      return yield* new DirectoryUnavailableError({ directory: input });
+    return resolved;
+  });
+  const strategy = makeGitWorktreeStrategy({ git, canonical });
+  const source = Effect.fnUntraced(function* (input, projectID) {
+    const sourceDirectory = yield* canonical(input);
+    if ((yield* directories.get({ projectID, directory: sourceDirectory })) === undefined)
+      return yield* new SourceDirectoryNotFoundError({ directory: sourceDirectory });
+    return sourceDirectory;
+  });
+  const getStrategy = Effect.fnUntraced(function* (id) {
+    if (id !== strategy.id)
+      return yield* new StrategyUnavailableError({ strategy: id });
+    return strategy;
+  });
+  const create = Effect.fn("ProjectCopy.create")(function* (input) {
+    const selected = yield* getStrategy(input.strategy);
+    const sourceDirectory = yield* source(input.sourceDirectory, input.projectID);
+    yield* fs.makeDirectory(input.directory, { recursive: true }).pipe(Effect.orDie);
+    const name = input.name ?? Slug.create();
+    let suffix = 1;
+    let copyDirectory = AbsolutePath.make(path.join(input.directory, name));
+    while (yield* fs.existsSafe(copyDirectory)) {
+      suffix++;
+      if (suffix > 10)
+        return yield* new DestinationExistsError({ directory: copyDirectory });
+      copyDirectory = AbsolutePath.make(path.join(input.directory, `${name}-${suffix}`));
+    }
+    const result = yield* selected.create({
+      directory: copyDirectory,
+      sourceDirectory
+    });
+    yield* changed(input.projectID, yield* directories.create({
+      projectID: input.projectID,
+      directory: result.directory,
+      strategy: input.strategy,
+      behavior: "replace"
+    }));
+    return result;
+  });
+  const remove = Effect.fn("ProjectCopy.remove")(function* (input) {
+    const copyDirectory = yield* canonical(input.directory);
+    const stored = yield* directories.get({ projectID: input.projectID, directory: copyDirectory });
+    if (!stored?.strategy)
+      return yield* new InvalidDirectoryError({ directory: copyDirectory });
+    const strategy2 = yield* getStrategy(StrategyID.make(stored.strategy));
+    yield* strategy2.remove({
+      directory: copyDirectory,
+      force: input.force
+    });
+    yield* changed(input.projectID, yield* directories.remove({ projectID: input.projectID, directory: copyDirectory }));
+  });
+  const refresh = Effect.fn("ProjectCopy.refresh")(function* (input) {
+    const stored = yield* directories.list(input.projectID);
+    const checked = yield* Effect.forEach(stored, (item) => fs.isDir(item.directory).pipe(Effect.map((exists) => ({ ...item, exists }))), { concurrency: "unbounded" });
+    const sourceDirectories = checked.filter((item) => item.strategy === undefined && item.exists).map((item) => item.directory);
+    const discovered = yield* Effect.forEach(sourceDirectories, (sourceDirectory) => strategy.list(sourceDirectory).pipe(Effect.catchTag("ProjectCopy.DirectoryUnavailableError", () => Effect.succeed([])), Effect.map((items) => items.map((item) => ({
+      directory: item.directory,
+      strategy: item.type === "copy" ? strategy.id : undefined
+    })))), { concurrency: "unbounded" }).pipe(Effect.map((sets) => new Map(sets.flat().map((item) => [item.directory, item])).values().toArray()));
+    const removed = checked.filter((item) => !item.exists).map((item) => item.directory);
+    const result = yield* db.transaction((tx) => Effect.all({
+      updated: Effect.forEach(discovered, (item) => directories.create({
+        projectID: input.projectID,
+        directory: item.directory,
+        strategy: item.strategy,
+        behavior: "replace"
+      }, tx)),
+      removed: Effect.forEach(removed, (directory) => directories.remove({ projectID: input.projectID, directory }, tx))
+    })).pipe(Effect.orDie);
+    const changes = {
+      updated: discovered.filter((_, index) => result.updated[index]).map((item) => item.directory),
+      removed: removed.filter((_, index) => result.removed[index])
+    };
+    yield* changed(input.projectID, changes.updated.length > 0 || changes.removed.length > 0);
+    return changes;
+  });
+  return Service.of({
+    create,
+    remove,
+    refresh
+  });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [FSUtil.node, exports_git.node, exports_directories.node, exports_bus.node, exports_database.node]
+});
+var refreshNode = makeLocationNode({
+  name: "project-copy-refresh",
+  layer: Layer.effectDiscard(refreshAfterBoot),
+  deps: [node, exports_location.node]
+});
+
+// src/project/copy-strategies.ts
+function makeGitWorktreeStrategy(input) {
+  return {
+    id: StrategyID.make("git_worktree"),
+    create: Effect2.fn("ProjectCopy.GitWorktree.create")(function* (options) {
+      const repository = yield* input.git.repo.discover(options.sourceDirectory);
+      if (!repository)
+        return yield* new DirectoryUnavailableError({ directory: options.sourceDirectory });
+      yield* input.git.worktree.create({ repository, directory: options.directory });
+      return { directory: yield* input.canonical(options.directory) };
+    }),
+    remove: Effect2.fn("ProjectCopy.GitWorktree.remove")(function* (options) {
+      const found = yield* input.git.repo.discover(options.directory);
+      if (!found)
+        return yield* new DirectoryUnavailableError({ directory: options.directory });
+      yield* input.git.worktree.remove({ repository: found, directory: options.directory, force: options.force });
+    }),
+    list: Effect2.fn("ProjectCopy.GitWorktree.list")(function* (directory) {
+      const found = yield* input.git.repo.discover(directory);
+      if (!found)
+        return yield* new DirectoryUnavailableError({ directory });
+      const entries = yield* input.git.worktree.list(found);
+      return yield* Effect2.forEach(entries, (entry) => input.canonical(entry.directory).pipe(Effect2.map((directory2) => ({ directory: directory2, type: entry.kind === "main" ? "root" : "copy" })), Effect2.catchTag("ProjectCopy.DirectoryUnavailableError", () => Effect2.succeed(undefined)))).pipe(Effect2.map((items) => items.filter((item) => item !== undefined)));
+    })
+  };
+}
+
+export { makeGitWorktreeStrategy, Event, StrategyID, CreateInput, RemoveInput, RefreshInput, RefreshResult, Copy, ListEntry, SourceDirectoryNotFoundError, DestinationExistsError, DirectoryUnavailableError, InvalidDirectoryError, StrategyUnavailableError, Service, refreshAfterBoot, node, refreshNode, exports_copy };

package/dist/chunks/permission-9f0rnpkn.js

@@ -0,0 +1,16 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/v1/config/plugin.ts
+var exports_plugin = {};
+__export(exports_plugin, {
+  Spec: () => Spec,
+  Options: () => Options,
+  ConfigPluginV1: () => exports_plugin
+});
+import { Schema } from "effect";
+var Options = Schema.Record(Schema.String, Schema.Unknown);
+var Spec = Schema.Union([Schema.String, Schema.mutable(Schema.Tuple([Schema.String, Options]))]);
+
+export { Options, Spec, exports_plugin };

package/dist/chunks/permission-9pygavrm.js

@@ -0,0 +1,145 @@
+import {
+  exports_filesystem
+} from "./permission-jm82nbh8.js";
+import {
+  exports_ripgrep
+} from "./permission-wvha5myg.js";
+import {
+  exports_environment1 as exports_environment
+} from "./permission-z5ystmxz.js";
+import {
+  exports_location_mutation
+} from "./permission-a2yyszsy.js";
+import {
+  exports_permission
+} from "./permission-qa8qg9jd.js";
+import {
+  exports_location
+} from "./permission-1e2ryyac.js";
+import {
+  RelativePath
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-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 };