@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-4bk5angc.js

@@ -0,0 +1,355 @@
+import {
+  fileDiff
+} from "./permission-c77ad0vh.js";
+import {
+  exports_file_mutation
+} from "./permission-2nkse5ac.js";
+import {
+  exports_formatter
+} from "./permission-w4678h5q.js";
+import {
+  exports_environment1 as exports_environment
+} from "./permission-z5ystmxz.js";
+import {
+  exports_permission
+} from "./permission-qa8qg9jd.js";
+import {
+  exports_location
+} from "./permission-1e2ryyac.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/tool/plugin/patch.ts
+var exports_patch = {};
+__export(exports_patch, {
+  toModelOutput: () => toModelOutput,
+  name: () => name,
+  Plugin: () => Plugin,
+  PatchTool: () => exports_patch,
+  Output: () => Output,
+  Input: () => Input,
+  Applied: () => Applied
+});
+import { ToolFailure } from "@opencode-ai/ai";
+import { FileDiff } from "@opencode-ai/schema/file-diff";
+import { Effect, Result, Schema } from "effect";
+import path from "path";
+import { Bom } from "@opencode-ai/util/bom";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Patch } from "@opencode-ai/util/patch";
+
+// src/tool/patch.txt
+var patch_default = `Use the \`patch\` tool to edit files. Your patch language is a stripped‑down, file‑oriented diff format designed to be easy to parse and safe to apply. You can think of it as a high‑level envelope:
+
+*** Begin Patch
+[ one or more file sections ]
+*** End Patch
+
+Within that envelope, you get a sequence of file operations.
+You MUST include a header to specify the action you are taking.
+Each operation starts with one of three headers:
+
+*** Add File: <path> - create a new file. Every following line is a + line (the initial contents).
+*** Delete File: <path> - remove an existing file. Nothing follows.
+*** Update File: <path> - patch an existing file in place (optionally with a rename).
+
+Example patch:
+
+\`\`\`
+*** Begin Patch
+*** Add File: hello.txt
++Hello world
+*** Update File: src/app.py
+*** Move to: src/main.py
+@@ def greet():
+-print("Hi")
++print("Hello, world!")
+*** Delete File: obsolete.txt
+*** End Patch
+\`\`\`
+
+It is important to remember:
+
+- You must include a header with your intended action (Add/Delete/Update)
+- You must prefix new lines with \`+\` even when creating a new file
+`;
+
+// src/tool/plugin/patch.ts
+var name = "patch";
+var Input = Schema.Struct({
+  patchText: Schema.String.annotate({
+    description: "The full patch text describing add, update, and delete operations"
+  })
+});
+var Applied = Schema.Struct({
+  type: Schema.Literals(["add", "update", "delete"]),
+  resource: Schema.String,
+  target: Schema.String
+});
+var Output = Schema.Struct({
+  applied: Schema.Array(Applied),
+  files: Schema.Array(FileDiff.Info)
+});
+var toModelOutput = (output) => [
+  "Success. Updated the following files:",
+  ...output.applied.map((item) => `${item.type === "add" ? "A" : item.type === "delete" ? "D" : "M"} ${item.resource}`)
+].join(`
+`);
+var Plugin = {
+  id: "opencode.tool.patch",
+  effect: Effect.fn("PatchTool.Plugin")(function* (ctx) {
+    const environment = yield* exports_environment.Service;
+    const mutation = yield* exports_file_mutation.Service;
+    const formatter = yield* exports_formatter.Service;
+    const location = yield* exports_location.Service;
+    const permission = yield* exports_permission.Service;
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false, permission: "edit" },
+      description: patch_default,
+      input: Input,
+      output: Output,
+      execute: (input, context) => {
+        const applied = [];
+        const parsed = Patch.parse(input.patchText);
+        const lockTargets = Result.isSuccess(parsed) ? parsed.success.flatMap((hunk) => [
+          path.resolve(location.directory, hunk.path),
+          ...hunk.type === "update" && hunk.movePath ? [path.resolve(location.directory, hunk.movePath)] : []
+        ]) : [];
+        const fail = (operation, error) => {
+          const completed = applied.map((item) => item.resource).join(", ");
+          return new ToolFailure({
+            message: `${operation}: ${errorMessage(error)}${completed ? `. Completed before failure: ${completed}` : ""}`
+          });
+        };
+        return Effect.gen(function* () {
+          const source = {
+            type: "tool",
+            messageID: context.messageID,
+            id: context.id
+          };
+          if (!input.patchText)
+            return yield* new ToolFailure({ message: "patchText is required" });
+          const hunks = yield* Effect.fromResult(parsed).pipe(Effect.mapError((error) => new ToolFailure({ message: `patch verification failed: ${error.message}` })));
+          if (hunks.length === 0) {
+            return yield* new ToolFailure({ message: "patch rejected: empty patch" });
+          }
+          const prepared = [];
+          const targets = [];
+          const updates = new Map;
+          for (const hunk of hunks) {
+            yield* Effect.gen(function* () {
+              const target = resolveTarget(location, hunk.path);
+              targets.push(target);
+              if (target.externalDirectory) {
+                yield* permission.assert({
+                  action: "external_directory",
+                  resources: [target.externalDirectory.resource],
+                  save: [target.externalDirectory.resource],
+                  metadata: {
+                    filepath: target.absolute,
+                    parentDir: target.externalDirectory.directory
+                  },
+                  sessionID: context.sessionID,
+                  agent: context.agent,
+                  source
+                });
+              }
+              if (hunk.type === "add") {
+                const content = hunk.contents.endsWith(`
+`) || hunk.contents === "" ? hunk.contents : `${hunk.contents}
+`;
+                prepared.push({
+                  ...hunk,
+                  target,
+                  content,
+                  before: "",
+                  after: Bom.split(content).text
+                });
+                return;
+              }
+              if (hunk.type === "delete") {
+                const content = yield* exports_file_mutation.readText(environment.files, target.absolute).pipe(Effect.mapError((error) => new ToolFailure({
+                  message: `patch verification failed: Failed to delete ${target.resource}: ${errorMessage(error)}`
+                })));
+                prepared.push({ ...hunk, target, before: content.text, after: "" });
+                return;
+              }
+              const previous = updates.get(target.absolute);
+              const original = previous ?? (yield* Effect.gen(function* () {
+                const content = yield* exports_file_mutation.readText(environment.files, target.absolute).pipe(Effect.mapError((error) => new ToolFailure({
+                  message: `patch verification failed: Failed to read file to update ${target.absolute}: ${errorMessage(error)}`
+                })));
+                return Bom.join(content.text, content.bom);
+              }));
+              const before = Bom.split(original).text;
+              const update = yield* Effect.try({
+                try: () => Patch.derive(hunk.path, hunk.chunks, original),
+                catch: (error) => new ToolFailure({ message: `patch verification failed: ${errorMessage(error)}` })
+              });
+              const moveTarget = hunk.movePath ? resolveTarget(location, hunk.movePath) : undefined;
+              if (moveTarget)
+                targets.push(moveTarget);
+              if (moveTarget?.externalDirectory) {
+                yield* permission.assert({
+                  action: "external_directory",
+                  resources: [moveTarget.externalDirectory.resource],
+                  save: [moveTarget.externalDirectory.resource],
+                  metadata: {
+                    filepath: moveTarget.absolute,
+                    parentDir: moveTarget.externalDirectory.directory
+                  },
+                  sessionID: context.sessionID,
+                  agent: context.agent,
+                  source
+                });
+              }
+              prepared.push({
+                ...hunk,
+                target,
+                content: Patch.joinBom(update.content, update.bom),
+                before,
+                after: update.content,
+                moveTarget
+              });
+              if (!moveTarget)
+                updates.set(target.absolute, Patch.joinBom(update.content, update.bom));
+            }).pipe(Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to prepare patch at ${hunk.path}`, error })));
+          }
+          const patchFiles = prepared.map((change) => patchFile(change));
+          yield* permission.assert({
+            action: "edit",
+            resources: [...new Set(targets.map((target) => target.resource))],
+            save: ["*"],
+            metadata: {
+              filepath: targets.map((target) => target.resource).join(", "),
+              diff: patchFiles.map((file) => `${file.patch}
+`).join(""),
+              files: patchFiles
+            },
+            sessionID: context.sessionID,
+            agent: context.agent,
+            source
+          });
+          yield* Effect.forEach(prepared, (change) => Effect.gen(function* () {
+            if (change.type === "add") {
+              yield* environment.files.write(change.target.absolute, new TextEncoder().encode(change.content)).pipe(Effect.mapError((error) => fail(`Failed to write ${change.target.resource}`, error)));
+              applied.push({
+                type: change.type,
+                resource: change.target.resource,
+                target: change.target.absolute
+              });
+              return;
+            }
+            if (change.type === "delete") {
+              yield* environment.files.remove(change.target.absolute).pipe(Effect.mapError((error) => fail(`Failed to delete ${change.target.resource}`, error)));
+              applied.push({
+                type: change.type,
+                resource: change.target.resource,
+                target: change.target.absolute
+              });
+              return;
+            }
+            if (change.moveTarget) {
+              const moveTarget = change.moveTarget;
+              yield* environment.files.write(moveTarget.absolute, new TextEncoder().encode(change.content)).pipe(Effect.mapError((error) => fail(`Failed to write ${moveTarget.resource}`, error)));
+              yield* environment.files.remove(change.target.absolute).pipe(Effect.mapError((error) => fail(`Wrote ${moveTarget.resource} but failed to remove ${change.target.resource}`, error)));
+              applied.push({
+                type: change.type,
+                resource: change.moveTarget.resource,
+                target: change.moveTarget.absolute
+              });
+              return;
+            }
+            yield* environment.files.write(change.target.absolute, new TextEncoder().encode(change.content)).pipe(Effect.mapError((error) => fail(`Failed to write ${change.target.resource}`, error)));
+            applied.push({
+              type: change.type,
+              resource: change.target.resource,
+              target: change.target.absolute
+            });
+          }), { discard: true });
+          const formatted = new Map;
+          yield* Effect.forEach([...new Set(applied.filter((item) => item.type !== "delete").map((item) => item.target))], (target) => Effect.gen(function* () {
+            const current = yield* exports_file_mutation.readText(environment.files, target).pipe(Effect.mapError((error) => fail(`Failed to read ${target}`, error)));
+            formatted.set(target, (yield* formatter.file(target)) ? yield* exports_file_mutation.syncTextBom(environment.files, target, current.bom).pipe(Effect.mapError((error) => fail(`Failed to sync ${target}`, error))) : current.text);
+          }), { discard: true });
+          const files = yield* Effect.forEach(prepared, (change) => {
+            if (change.type === "delete")
+              return Effect.succeed(patchFile(change));
+            const target = change.type === "update" && change.moveTarget ? change.moveTarget : change.target;
+            return Effect.succeed(patchFile(change, formatted.get(target.absolute)));
+          });
+          return { applied, files };
+        }).pipe(mutation.withLock(lockTargets), Effect.map((output) => ({
+          output,
+          content: toModelOutput(output),
+          metadata: { files: output.files }
+        })), Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: "Unable to apply patch", error })));
+      }
+    })).pipe(Effect.orDie);
+    yield* ctx.session.hook("context", (event) => Effect.sync(() => {
+      const usePatch = event.model.id.includes("gpt-") && !event.model.id.includes("oss") && !event.model.id.includes("gpt-4");
+      if (usePatch) {
+        delete event.tools.edit;
+        delete event.tools.write;
+        return;
+      }
+      delete event.tools.patch;
+    }));
+  })
+};
+function errorMessage(error) {
+  if (error instanceof exports_environment.NotFound)
+    return "file does not exist";
+  if (error instanceof exports_environment.WrongKind)
+    return error.actual === "directory" ? "path is a directory" : `path is ${error.actual}`;
+  if (error instanceof exports_environment.Failed)
+    return errorMessage(error.cause);
+  return error instanceof Error ? error.message : String(error);
+}
+function patchFile(change, after = change.after) {
+  const target = (change.type === "update" ? change.moveTarget : undefined)?.resource ?? change.target.resource;
+  const diff = fileDiff(change.target.absolute, change.before, after, change.type === "add" ? "added" : change.type === "delete" ? "deleted" : "modified");
+  return {
+    ...diff,
+    file: target,
+    patch: trimDiff(diff.patch)
+  };
+}
+function trimDiff(diff) {
+  const lines = diff.split(`
+`);
+  const content = lines.filter((line) => (line.startsWith("+") || line.startsWith("-") || line.startsWith(" ")) && !line.startsWith("---") && !line.startsWith("+++"));
+  if (content.length === 0)
+    return diff;
+  const indent = content.reduce((result, line) => {
+    const value = line.slice(1);
+    if (value.trim().length === 0)
+      return result;
+    return Math.min(result, value.match(/^(\s*)/)?.[1].length ?? result);
+  }, Infinity);
+  if (indent === Infinity || indent === 0)
+    return diff;
+  return lines.map((line) => {
+    if ((line.startsWith("+") || line.startsWith("-") || line.startsWith(" ")) && !line.startsWith("---") && !line.startsWith("+++")) {
+      return line[0] + line.slice(1 + indent);
+    }
+    return line;
+  }).join(`
+`);
+}
+function resolveTarget(location, value) {
+  const absolute = process.platform === "win32" ? FSUtil.normalizePath(path.resolve(location.directory, value)) : path.resolve(location.directory, value);
+  const projectRoot = path.parse(location.project.directory).root;
+  const external = !FSUtil.contains(location.directory, absolute) && (location.project.directory === projectRoot || !FSUtil.contains(location.project.directory, absolute));
+  const directory = path.dirname(absolute);
+  const resource = process.platform === "win32" ? FSUtil.normalizePathPattern(path.join(directory, "*")) : path.join(directory, "*").replaceAll("\\", "/");
+  return {
+    absolute,
+    resource: path.relative(location.project.directory, absolute).replaceAll("\\", "/") || ".",
+    externalDirectory: external ? { directory, resource } : undefined
+  };
+}
+
+export { name, Input, Applied, Output, toModelOutput, Plugin, exports_patch };

package/dist/chunks/permission-4s2xwh5d.js

@@ -0,0 +1,91 @@
+import {
+  exports_permission
+} from "./permission-v9bfv94f.js";
+import {
+  PositiveInt
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/v1/config/agent.ts
+var exports_agent = {};
+__export(exports_agent, {
+  Info: () => Info,
+  ConfigAgentV1: () => exports_agent
+});
+import { Schema, SchemaGetter } from "effect";
+var Color = Schema.Union([
+  Schema.String.check(Schema.isPattern(/^#[0-9a-fA-F]{6}$/)),
+  Schema.Literals(["primary", "secondary", "accent", "success", "warning", "error", "info"])
+]);
+var AgentSchema = Schema.StructWithRest(Schema.Struct({
+  model: Schema.optional(Schema.String),
+  variant: Schema.optional(Schema.String).annotate({
+    description: "Default model variant for this agent (applies only when using the agent's configured model)."
+  }),
+  temperature: Schema.optional(Schema.Finite),
+  top_p: Schema.optional(Schema.Finite),
+  prompt: Schema.optional(Schema.String),
+  tools: Schema.optional(Schema.Record(Schema.String, Schema.Boolean)).annotate({
+    description: "@deprecated Use 'permission' field instead"
+  }),
+  disable: Schema.optional(Schema.Boolean),
+  description: Schema.optional(Schema.String).annotate({ description: "Description of when to use the agent" }),
+  mode: Schema.optional(Schema.Literals(["subagent", "primary", "all"])),
+  hidden: Schema.optional(Schema.Boolean).annotate({
+    description: "Hide this subagent from the @ autocomplete menu (default: false, only applies to mode: subagent)"
+  }),
+  options: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
+  color: Schema.optional(Color).annotate({
+    description: "Hex color code (e.g., #FF5733) or theme color (e.g., primary)"
+  }),
+  steps: Schema.optional(PositiveInt).annotate({
+    description: "Maximum number of agentic iterations before forcing text-only response"
+  }),
+  maxSteps: Schema.optional(PositiveInt).annotate({ description: "@deprecated Use 'steps' field instead." }),
+  permission: Schema.optional(exports_permission.Info)
+}), [Schema.Record(Schema.String, Schema.Any)]);
+var KNOWN_KEYS = new Set([
+  "name",
+  "model",
+  "variant",
+  "prompt",
+  "description",
+  "temperature",
+  "top_p",
+  "mode",
+  "hidden",
+  "color",
+  "steps",
+  "maxSteps",
+  "options",
+  "permission",
+  "disable",
+  "tools"
+]);
+var normalize = (agent) => {
+  const options = { ...agent.options };
+  for (const [key, value] of Object.entries(agent)) {
+    if (!KNOWN_KEYS.has(key))
+      options[key] = value;
+  }
+  const permission = {};
+  for (const [tool, enabled] of Object.entries(agent.tools ?? {})) {
+    const action = enabled ? "allow" : "deny";
+    if (tool === "write" || tool === "edit" || tool === "patch") {
+      permission.edit = action;
+      continue;
+    }
+    permission[tool] = action;
+  }
+  globalThis.Object.assign(permission, agent.permission);
+  const steps = agent.steps ?? agent.maxSteps;
+  return { ...agent, options, permission, ...steps !== undefined ? { steps } : {} };
+};
+var Info = AgentSchema.pipe(Schema.decodeTo(AgentSchema, {
+  decode: SchemaGetter.transform(normalize),
+  encode: SchemaGetter.passthrough({ strict: false })
+})).annotate({ identifier: "AgentConfig" });
+
+export { Info, exports_agent };

package/dist/chunks/permission-4szcs9x3.js

@@ -0,0 +1,94 @@
+import {
+  schema_gen_default
+} from "./permission-hy0hzg1s.js";
+import {
+  migrations
+} from "./permission-707etsmq.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/database/migration.ts
+var exports_migration = {};
+__export(exports_migration, {
+  applyOnly: () => applyOnly,
+  apply: () => apply,
+  DatabaseMigration: () => exports_migration
+});
+import { sql } from "drizzle-orm";
+import { Effect, Semaphore } from "effect";
+import { supportsForeignKeyToggle } from "#sqlite";
+var lock = Semaphore.makeUnsafe(1);
+function apply(db) {
+  return lock.withPermit(Effect.gen(function* () {
+    const tables = yield* db.all(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND substr(name, 1, 1) <> '_'`);
+    if (tables.some((table) => table.name === "session" || table.name === "session_v2"))
+      return yield* applyOnly(db, migrations);
+    if (tables.length > 0)
+      return yield* Effect.die(new Error("Database is not empty and has no session table"));
+    const started = Date.now();
+    yield* Effect.logInfo("database schema bootstrap started", { migrations: migrations.length });
+    yield* db.transaction((tx) => Effect.gen(function* () {
+      yield* schema_gen_default.up(tx);
+      yield* tx.run(sql`CREATE TABLE ${sql.identifier("migration")} (id TEXT PRIMARY KEY, time_completed INTEGER NOT NULL)`);
+      yield* Effect.forEach(migrations, (migration) => tx.run(sql`INSERT INTO ${sql.identifier("migration")} (id, time_completed) VALUES (${migration.id}, ${Date.now()})`));
+    }));
+    yield* Effect.logInfo("database schema bootstrap completed", {
+      migrations: migrations.length,
+      durationMs: Date.now() - started
+    });
+  }));
+}
+function applyOnly(db, input) {
+  return Effect.gen(function* () {
+    yield* db.run(sql`CREATE TABLE IF NOT EXISTS ${sql.identifier("migration")} (id TEXT PRIMARY KEY, time_completed INTEGER NOT NULL)`);
+    let completed = new Set((yield* db.all(sql`SELECT id FROM ${sql.identifier("migration")}`)).map((row) => row.id));
+    if (completed.size === 0) {
+      if (yield* db.get(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${"__drizzle_migrations"}`)) {
+        yield* db.run(sql`
+          INSERT OR IGNORE INTO ${sql.identifier("migration")} (id, time_completed)
+          SELECT name, ${Date.now()}
+          FROM ${sql.identifier("__drizzle_migrations")}
+          WHERE name IS NOT NULL
+        `);
+        completed = new Set((yield* db.all(sql`SELECT id FROM ${sql.identifier("migration")}`)).map((row) => row.id));
+      }
+    }
+    for (const migration of input) {
+      if (completed.has(migration.id))
+        continue;
+      const started = Date.now();
+      yield* Effect.logInfo("database migration started", { migration: migration.id });
+      const apply2 = db.transaction((tx) => Effect.gen(function* () {
+        yield* migration.up(tx);
+        yield* tx.run(sql`INSERT INTO ${sql.identifier("migration")} (id, time_completed) VALUES (${migration.id}, ${Date.now()})`);
+      }));
+      if (migration.foreignKeys !== false) {
+        yield* apply2.pipe(Effect.tapError((error) => Effect.logError("database migration failed", {
+          migration: migration.id,
+          durationMs: Date.now() - started,
+          error
+        })));
+        yield* Effect.logInfo("database migration completed", {
+          migration: migration.id,
+          durationMs: Date.now() - started
+        });
+        continue;
+      }
+      const relaxForeignKeys = supportsForeignKeyToggle ? db.run(sql`PRAGMA foreign_keys = OFF`) : db.run(sql`PRAGMA defer_foreign_keys = ON`);
+      const restoreForeignKeys = supportsForeignKeyToggle ? db.run(sql`PRAGMA foreign_keys = ON`) : Effect.void;
+      yield* relaxForeignKeys;
+      yield* apply2.pipe(Effect.ensuring(restoreForeignKeys.pipe(Effect.orDie)), Effect.tapError((error) => Effect.logError("database migration failed", {
+        migration: migration.id,
+        durationMs: Date.now() - started,
+        error
+      })));
+      yield* Effect.logInfo("database migration completed", {
+        migration: migration.id,
+        durationMs: Date.now() - started
+      });
+    }
+  });
+}
+
+export { apply, applyOnly, exports_migration };