@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-wt193r4g.js

@@ -0,0 +1,130 @@
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/state.ts
+var exports_state = {};
+__export(exports_state, {
+  inherit: () => inherit,
+  create: () => create,
+  batch: () => batch,
+  State: () => exports_state
+});
+import { Clock, Context, Deferred, Effect, Scope, Semaphore } from "effect";
+var CurrentBatch = Context.Reference("@opencode/State/CurrentBatch", {
+  defaultValue: () => {
+    return;
+  }
+});
+var reloadDebounce = 500;
+function batch(effect) {
+  return Effect.gen(function* () {
+    const current = yield* CurrentBatch;
+    if (current?.active)
+      return yield* effect;
+    const batch2 = { active: true, reloads: new Set };
+    const exit = yield* effect.pipe(Effect.provideService(CurrentBatch, batch2), Effect.exit);
+    batch2.active = false;
+    yield* Effect.forEach(batch2.reloads, (reload) => reload(), { discard: true });
+    return yield* exit;
+  });
+}
+var inherit = Effect.fnUntraced(function* () {
+  const batch2 = yield* CurrentBatch;
+  return (effect) => Effect.provideService(effect, CurrentBatch, batch2);
+});
+function create(options) {
+  let state = options.initial();
+  let transforms = [];
+  let generation = 0;
+  let requestedAt = 0;
+  let running = false;
+  let waiters = [];
+  const semaphore = Semaphore.makeUnsafe(1);
+  const commit = Effect.fn("State.commit")(function* (next) {
+    state = next;
+    if (options.finalize)
+      yield* options.finalize(options.draft(next));
+  });
+  const apply = (transform, draft) => Effect.sync(() => {
+    transform(draft);
+  });
+  const materialize = Effect.fnUntraced(function* () {
+    const next = options.initial();
+    const api = options.draft(next);
+    for (const transform of transforms)
+      yield* apply(transform.run, api).pipe(Effect.withSpan("State.reload.update", { attributes: { state: options.name ?? "anonymous" } }));
+    yield* commit(next);
+  });
+  const materializeReload = () => semaphore.withPermit(materialize());
+  const rebuild = () => Effect.gen(function* () {
+    const clock = yield* Clock.Clock;
+    const remaining = requestedAt + reloadDebounce - clock.currentTimeMillisUnsafe();
+    if (remaining > 0)
+      yield* Effect.sleep(remaining);
+    if (clock.currentTimeMillisUnsafe() < requestedAt + reloadDebounce)
+      return yield* rebuild();
+    const target = generation;
+    const exit = yield* materializeReload().pipe(Effect.exit);
+    const completed = waiters.filter((waiter) => waiter.generation <= target);
+    waiters = waiters.filter((waiter) => waiter.generation > target);
+    yield* Effect.forEach(completed, (waiter) => Deferred.done(waiter.done, exit), {
+      concurrency: "unbounded",
+      discard: true
+    });
+    if (generation > target)
+      return yield* rebuild();
+    running = false;
+  });
+  const reload = Effect.fnUntraced(function* () {
+    const done = Deferred.makeUnsafe();
+    const clock = yield* Clock.Clock;
+    generation++;
+    requestedAt = clock.currentTimeMillisUnsafe();
+    waiters.push({ generation, done });
+    if (!running) {
+      running = true;
+      yield* rebuild().pipe(Effect.forkDetach);
+    }
+    return yield* Deferred.await(done);
+  });
+  const result = {
+    get: () => state,
+    transform: Effect.fn("State.transform")(function* (update) {
+      yield* Effect.annotateCurrentSpan("state", options.name ?? "anonymous");
+      const scope = yield* Scope.Scope;
+      return yield* Effect.uninterruptible(Effect.gen(function* () {
+        const transform = { run: update };
+        let active = true;
+        const dispose = Effect.uninterruptible(semaphore.withPermit(Effect.suspend(() => {
+          if (!active)
+            return Effect.void;
+          active = false;
+          transforms = transforms.filter((item) => item !== transform);
+          return Effect.gen(function* () {
+            const batch3 = yield* CurrentBatch;
+            if (batch3?.active) {
+              batch3.reloads.add(materializeReload);
+              return;
+            }
+            yield* materialize();
+          });
+        })));
+        yield* semaphore.withPermit(Effect.sync(() => {
+          transforms = [...transforms, transform];
+        }));
+        yield* Scope.addFinalizer(scope, dispose);
+        const batch2 = yield* CurrentBatch;
+        if (batch2?.active)
+          batch2.reloads.add(materializeReload);
+        else
+          yield* materializeReload();
+        return { dispose };
+      }));
+    }),
+    reload
+  };
+  return result;
+}
+
+export { batch, inherit, create, exports_state };

package/dist/chunks/ripgrep-wtn6swg6.js

@@ -0,0 +1,106 @@
+import {
+  fileDiff
+} from "./ripgrep-c77ad0vh.js";
+import {
+  exports_location_mutation
+} from "./ripgrep-0vcm5yws.js";
+import {
+  exports_formatter
+} from "./ripgrep-qvqgqyrp.js";
+import {
+  exports_file_mutation
+} from "./ripgrep-s87vpmv3.js";
+import {
+  exports_environment1 as exports_environment
+} from "./ripgrep-bfaw9j5x.js";
+import {
+  exports_permission
+} from "./ripgrep-x5r76fqd.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/tool/plugin/write.ts
+var exports_write = {};
+__export(exports_write, {
+  toModelOutput: () => toModelOutput,
+  name: () => name,
+  WriteTool: () => exports_write,
+  Plugin: () => Plugin,
+  Output: () => Output,
+  Input: () => Input
+});
+import { ToolFailure } from "@opencode-ai/ai";
+import { Effect, Schema } from "effect";
+import { Bom } from "@opencode-ai/util/bom";
+var name = "write";
+var Input = Schema.Struct({
+  path: Schema.String.annotate({
+    description: "Path to the file to write to"
+  }),
+  content: Schema.String.annotate({ description: "Content to write to the file" })
+});
+var Output = Schema.Struct({
+  operation: Schema.Literal("write"),
+  target: Schema.String,
+  resource: Schema.String,
+  existed: Schema.Boolean
+});
+var toModelOutput = (output) => `${output.existed ? "Wrote" : "Created"} file successfully: ${output.resource}`;
+var Plugin = {
+  id: "opencode.tool.write",
+  effect: Effect.fn("WriteTool.Plugin")(function* (ctx) {
+    const mutation = yield* exports_location_mutation.Service;
+    const fileMutation = yield* exports_file_mutation.Service;
+    const environment = yield* exports_environment.Service;
+    const formatter = yield* exports_formatter.Service;
+    const permission = yield* exports_permission.Service;
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false, permission: "edit" },
+      description: `Writes a file to the local filesystem, overwriting if one exists.
+
+Missing parent directories are created automatically.
+
+Use this tool to create new files or overwrite existing files. For partial changes, use the edit tool instead.`,
+      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, kind: "file" });
+        const external = target.externalDirectory;
+        if (external)
+          yield* permission.assert({
+            ...exports_location_mutation.externalDirectoryPermission(external),
+            sessionID: context.sessionID,
+            agent: context.agent,
+            source
+          });
+        const current = yield* exports_file_mutation.readText(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.succeed(undefined)));
+        const next = Bom.split(input.content);
+        const preview = fileDiff(target.resource, current?.text ?? "", next.text, current ? "modified" : "added");
+        yield* permission.assert({
+          action: "edit",
+          resources: [target.resource],
+          save: ["*"],
+          metadata: { files: [preview] },
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source
+        });
+        const result = yield* fileMutation.writeTextPreservingBom({ target, content: input.content });
+        const bom = (yield* exports_file_mutation.readText(environment.files, target.absolute)).bom;
+        if (yield* formatter.file(target.absolute)) {
+          yield* exports_file_mutation.syncTextBom(environment.files, target.absolute, bom);
+        }
+        return result;
+      }).pipe(Effect.map((output) => ({ output, content: toModelOutput(output) })), Effect.mapError((error) => new ToolFailure({ message: `Unable to write ${input.path}`, error })))
+    })).pipe(Effect.orDie);
+  })
+};
+
+export { name, Input, Output, toModelOutput, Plugin, exports_write };

package/dist/chunks/ripgrep-wwntjmk1.js

@@ -0,0 +1,13 @@
+// src/database/migration/20260211171708_add_project_commands.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260211171708_add_project_commands",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`project\` ADD \`commands\` text;`);
+    });
+  }
+};
+var _20260211171708_add_project_commands_default = migration;
+
+export { _20260211171708_add_project_commands_default };

package/dist/chunks/ripgrep-wx89ywv3.js

@@ -0,0 +1,104 @@
+// src/database/migration/20260805200742_import_legacy_credentials.ts
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { sql } from "drizzle-orm";
+import { Effect, Option, Schema } from "effect";
+import { Credential } from "@opencode-ai/schema/credential";
+import { Integration } from "@opencode-ai/schema/integration";
+import { NonNegativeInt } from "@opencode-ai/schema/schema";
+import { Global } from "@opencode-ai/util/global";
+var LegacyOAuth = Schema.Struct({
+  type: Schema.Literal("oauth"),
+  refresh: Schema.String,
+  access: Schema.String,
+  expires: NonNegativeInt,
+  accountId: Schema.optional(Schema.String),
+  enterpriseUrl: Schema.optional(Schema.String)
+});
+var LegacyKey = Schema.Struct({
+  type: Schema.Literal("api"),
+  key: Schema.String,
+  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String))
+});
+var LegacyWellKnown = Schema.Struct({
+  type: Schema.Literal("wellknown"),
+  key: Schema.String,
+  token: Schema.String
+});
+var LegacyValue = Schema.Union([LegacyOAuth, LegacyKey, LegacyWellKnown]);
+var decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString);
+var decodeValue = Schema.decodeUnknownOption(LegacyValue);
+var wellKnownSourcesKey = "wellknown:sources";
+var migration = {
+  id: "20260805200742_import_legacy_credentials",
+  up(tx) {
+    return Effect.gen(function* () {
+      const global = yield* Global.Service;
+      return yield* importLegacyCredentials(tx, path.join(global.data, "auth.json"));
+    });
+  }
+};
+var _20260805200742_import_legacy_credentials_default = migration;
+function importLegacyCredentials(tx, filepath) {
+  return Effect.gen(function* () {
+    const content = yield* Effect.promise(() => readFile(filepath, "utf8").catch(() => {
+      return;
+    }));
+    if (content === undefined)
+      return;
+    const input = Option.getOrUndefined(decodeJson(content));
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
+      return yield* Effect.fail(new Error("Legacy credential file must contain an object"));
+    }
+    const origins = [];
+    for (const [id, raw] of Object.entries(input)) {
+      const value2 = Option.getOrUndefined(decodeValue(raw));
+      if (!value2)
+        continue;
+      const integrationID = id.replace(/\/+$/, "");
+      if (!integrationID)
+        continue;
+      if (value2.type === "wellknown")
+        origins.push(integrationID);
+      if (yield* tx.get(sql`SELECT id FROM credential WHERE integration_id = ${integrationID}`))
+        continue;
+      const credential = value2.type === "api" ? Credential.Key.make({ type: "key", key: value2.key, metadata: value2.metadata }) : value2.type === "wellknown" ? Credential.Key.make({ type: "key", key: value2.token }) : Credential.OAuth.make({
+        type: "oauth",
+        methodID: Integration.MethodID.make(methodID(integrationID)),
+        refresh: value2.refresh,
+        access: value2.access,
+        expires: value2.expires,
+        metadata: value2.accountId || value2.enterpriseUrl ? {
+          ...value2.accountId ? { accountID: value2.accountId } : {},
+          ...value2.enterpriseUrl ? { enterpriseUrl: value2.enterpriseUrl } : {}
+        } : undefined
+      });
+      const now2 = Date.now();
+      yield* tx.run(sql`
+        INSERT INTO credential (id, integration_id, label, value, time_created, time_updated)
+        VALUES (${Credential.ID.create()}, ${integrationID}, 'default', ${JSON.stringify(credential)}, ${now2}, ${now2})
+      `);
+    }
+    if (!origins.length)
+      return;
+    const stored = yield* tx.get(sql`SELECT value FROM kv WHERE key = ${wellKnownSourcesKey}`);
+    const decoded = stored ? Option.getOrUndefined(decodeJson(stored.value)) : undefined;
+    const current = Array.isArray(decoded) ? decoded.filter((item) => typeof item === "string") : [];
+    const value = JSON.stringify(Array.from(new Set([...current, ...origins])));
+    const now = Date.now();
+    yield* tx.run(sql`
+      INSERT INTO kv (key, value, time_created, time_updated)
+      VALUES (${wellKnownSourcesKey}, ${value}, ${now}, ${now})
+      ON CONFLICT (key) DO UPDATE SET value = excluded.value, time_updated = excluded.time_updated
+    `);
+  });
+}
+function methodID(integrationID) {
+  if (integrationID === "openai")
+    return "chatgpt-browser";
+  if (["github-copilot", "opencode", "xai"].includes(integrationID))
+    return "device";
+  return "oauth";
+}
+
+export { importLegacyCredentials, _20260805200742_import_legacy_credentials_default };