@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-qm5vd5ej.js

@@ -0,0 +1,128 @@
+import {
+  typeFollowing2
+} from "./aisdk-native-2a5m3afh.js";
+import {
+  RelativePath2
+} from "./aisdk-native-922hggd3.js";
+import {
+  Service73
+} from "./aisdk-native-6fyvx278.js";
+import {
+  Service71
+} from "./aisdk-native-ms882c9x.js";
+import {
+  Service70
+} from "./aisdk-native-dp3vq9x5.js";
+import {
+  DEFAULT_SEARCH_LIMIT2,
+  DEFAULT_SEARCH_TIMEOUT_MS2,
+  GlobInput2,
+  Entry2
+} from "./aisdk-native-twwx0ekz.js";
+import {
+  Service59
+} from "./aisdk-native-h05a6ep0.js";
+import {
+  Service17
+} from "./aisdk-native-svw2bsx3.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/tool/plugin/glob.ts
+var exports_glob = {};
+__export(exports_glob, {
+  GlobTool: () => exports_glob,
+  Input: () => Input4,
+  Output: () => Output3,
+  Plugin: () => Plugin36,
+  name: () => name4,
+  toModelContent: () => toModelContent2
+});
+import { ToolFailure } from "@opencode/ai";
+import { Effect, Schema } from "effect";
+import path from "path";
+var name4 = "glob";
+var Input4 = Schema.Struct({
+  pattern: GlobInput2.fields.pattern.annotate({ description: "Glob pattern to match files against" }),
+  path: Schema.optionalKey(RelativePath2).annotate({
+    description: "Directory to search. Defaults to the current working directory."
+  }),
+  hidden: GlobInput2.fields.hidden.annotate({
+    description: "Include hidden files and directories (default: false)."
+  }),
+  limit: GlobInput2.fields.limit.annotate({
+    description: `Maximum number of matching files to return (default: ${DEFAULT_SEARCH_LIMIT2})`
+  })
+});
+var Output3 = Schema.Array(Entry2);
+var toModelContent2 = (entries, truncated = false) => {
+  const lines = entries.length === 0 ? ["No files found"] : entries.map((item) => item.path);
+  if (truncated)
+    lines.push("", `(Results are truncated: showing first ${entries.length} results. Consider using a more specific path or pattern.)`);
+  return lines.join(`
+`);
+};
+var Plugin36 = {
+  id: "opencode.tool.glob",
+  effect: Effect.fn("GlobTool.Plugin")(function* (ctx) {
+    const environment = yield* Service71;
+    const ripgrep = yield* Service70;
+    const location = yield* Service73;
+    const access = yield* Service17;
+    const permission = yield* Service59;
+    yield* ctx.tool.transform((editor) => editor.add({
+      name: name4,
+      options: { codemode: false },
+      description: 'Search file paths using a glob pattern (examples: "**/*.ts", "src/**/*.tsx").',
+      input: Input4,
+      output: Output3,
+      execute: (input, context) => Effect.gen(function* () {
+        const searchPath = input.path === "undefined" || input.path === "null" ? undefined : input.path;
+        const source = { type: "tool", messageID: context.messageID, id: context.id };
+        const target = yield* access.resolve({ path: searchPath ?? ".", kind: "directory" });
+        yield* access.authorizeExternal([target], context);
+        yield* permission.assert({
+          action: name4,
+          resources: [input.pattern],
+          save: ["*"],
+          metadata: {
+            root: searchPath ?? ".",
+            path: searchPath,
+            hidden: input.hidden,
+            limit: input.limit
+          },
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source
+        });
+        const type = yield* typeFollowing2(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new ToolFailure({ message: `Search path does not exist: ${searchPath ?? "."}` }))));
+        if (type !== "directory")
+          return yield* Effect.fail(new ToolFailure({ message: `Search path is not a directory: ${searchPath ?? "."}` }));
+        const root = target.absolute;
+        const limit = input.limit ?? DEFAULT_SEARCH_LIMIT2;
+        const entries = yield* ripgrep.glob({
+          cwd: root,
+          pattern: input.pattern,
+          hidden: input.hidden,
+          limit: limit + 1
+        }).pipe(Effect.timeoutOrElse({
+          duration: DEFAULT_SEARCH_TIMEOUT_MS2,
+          orElse: () => Effect.fail(new ToolFailure({
+            message: `Search timed out after ${DEFAULT_SEARCH_TIMEOUT_MS2 / 1000} seconds. Consider using a more specific path or pattern.`
+          }))
+        }), Effect.map((result) => result.map((entry) => Entry2.make({
+          ...entry,
+          path: RelativePath2.make(path.relative(location.directory, path.resolve(root, entry.path)))
+        }))));
+        return { entries: entries.slice(0, limit), truncated: entries.length > limit };
+      }).pipe(Effect.map((result) => ({
+        output: result.entries,
+        content: toModelContent2(result.entries.map((entry) => ({ ...entry, path: path.resolve(location.directory, entry.path) })), result.truncated),
+        metadata: { count: result.entries.length, truncated: result.truncated }
+      })), Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to find files matching ${input.pattern}`, error })))
+    })).pipe(Effect.orDie);
+  })
+};
+
+export { name4, Input4, Output3, toModelContent2, Plugin36, exports_glob };

package/dist/chunks/aisdk-native-qrg20bc0.js

@@ -0,0 +1,26 @@
+// src/database/migration/20260413175956_chief_energizer.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260413175956_chief_energizer",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`session_entry\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          \`data\` text NOT NULL,
+          CONSTRAINT \`fk_session_entry_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`CREATE INDEX \`session_entry_session_idx\` ON \`session_entry\` (\`session_id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_entry_session_type_idx\` ON \`session_entry\` (\`session_id\`,\`type\`);`);
+      yield* tx.run(`CREATE INDEX \`session_entry_time_created_idx\` ON \`session_entry\` (\`time_created\`);`);
+    });
+  }
+};
+var _20260413175956_chief_energizer_default = migration;
+
+export { _20260413175956_chief_energizer_default };

package/dist/chunks/aisdk-native-qsdy395h.js

@@ -0,0 +1,20 @@
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/config/plugin/entry-observer.ts
+var exports_entry_observer = {};
+__export(exports_entry_observer, {
+  ConfigEntryObserver: () => exports_entry_observer,
+  observe: () => observe2
+});
+import { Effect, Stream } from "effect";
+var observe2 = Effect.fnUntraced(function* (config, event, reload) {
+  const loaded = { entries: yield* config.entries() };
+  const refresh = config.entries().pipe(Effect.tap((entries) => Effect.sync(() => loaded.entries = entries)), Effect.andThen(reload));
+  yield* event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(() => refresh), Effect.forkScoped({ startImmediately: true }));
+  loaded.entries = yield* config.entries();
+  return loaded;
+});
+
+export { observe2, exports_entry_observer };

package/dist/chunks/aisdk-native-qv308p2a.js

@@ -0,0 +1,325 @@
+import {
+  Service80
+} from "./aisdk-native-vfccn5yp.js";
+import {
+  Service79
+} from "./aisdk-native-11nvngjf.js";
+import {
+  Service42
+} from "./aisdk-native-81rrwt6s.js";
+import {
+  userNotification2
+} from "./aisdk-native-fxbjtjnd.js";
+import {
+  SessionMessage2
+} from "./aisdk-native-gftt206x.js";
+import {
+  NotFoundError7,
+  PromptConflictError2,
+  SyntheticConflictError2,
+  CompactionConflictError2,
+  BusyError2,
+  InboxConflictError2
+} from "./aisdk-native-3x8gcmrs.js";
+import {
+  SessionEvent2
+} from "./aisdk-native-ec1grn59.js";
+import {
+  Service61
+} from "./aisdk-native-smbad60v.js";
+import {
+  Delivery2,
+  SyntheticPayload2,
+  Service40
+} from "./aisdk-native-0fm13a2s.js";
+import {
+  Service38
+} from "./aisdk-native-ynnjbwyb.js";
+import {
+  prepare2
+} from "./aisdk-native-6yxvt9sa.js";
+import {
+  stage2,
+  clear2,
+  commit2
+} from "./aisdk-native-9r7q4bhe.js";
+import {
+  start2
+} from "./aisdk-native-vy36sswr.js";
+import {
+  get4
+} from "./aisdk-native-83s1p0p4.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/session/session.ts
+var exports_session2 = {};
+__export(exports_session2, {
+  Session: () => exports_session2,
+  make: () => make12
+});
+import { DateTime, Effect, Fiber, Scope } from "effect";
+import { Event } from "@opencode/schema/event";
+import { FSUtil } from "@opencode/util/fs-util";
+var make12 = Effect.fn("Session.make")(function* () {
+  const bus = yield* Service79;
+  const database = yield* Service80;
+  const store = yield* Service61;
+  const instances = yield* Service42;
+  const execution = yield* Service38;
+  const admission = yield* Service40;
+  const fs = yield* FSUtil.Service;
+  const scope = yield* Scope.Scope;
+  const get = Effect.fn("Session.get")(function* (sessionID) {
+    const session = yield* store.get(sessionID);
+    if (!session)
+      return yield* new NotFoundError7({ sessionID });
+    return session;
+  });
+  const message = Effect.fn("Session.message")(function* (sessionID, messageID) {
+    const stored = yield* store.message(messageID);
+    return stored?.sessionID === sessionID ? stored.message : undefined;
+  });
+  const view = Effect.fn("Session.view")(function* (sessionID, input) {
+    const session = yield* get(sessionID);
+    if (session.time.idle === undefined || input.idle > DateTime.toEpochMillis(session.time.idle) || session.time.viewed !== undefined && DateTime.toEpochMillis(session.time.viewed) >= input.idle)
+      return;
+    yield* bus.publish(SessionEvent2.Viewed, { sessionID, idle: input.idle });
+  });
+  const rename = Effect.fn("Session.rename")(function* (sessionID, input) {
+    yield* get(sessionID);
+    yield* bus.publish(SessionEvent2.Renamed, { sessionID, title: input.title });
+  });
+  const setPermissions = Effect.fn("Session.setPermissions")(function* (sessionID, input) {
+    yield* get(sessionID);
+    yield* bus.publish(SessionEvent2.PermissionsUpdated, { sessionID, permissions: input.permissions });
+  });
+  const switchAgent = Effect.fn("Session.switchAgent")(function* (sessionID, input) {
+    const session = yield* get(sessionID);
+    yield* bus.publish(SessionEvent2.AgentSelected, { sessionID, agent: input.agent, previous: session.agent });
+  });
+  const switchModel = Effect.fn("Session.switchModel")(function* (sessionID, input) {
+    const session = yield* get(sessionID);
+    if (session.model?.providerID === input.model.providerID && session.model.id === input.model.id && (session.model.variant ?? "default") === (input.model.variant ?? "default"))
+      return;
+    yield* bus.publish(SessionEvent2.ModelSelected, { sessionID, model: input.model, previous: session.model });
+  });
+  const mutatePending = (sessionID, inboxID, mutation) => mutation({ sessionID, id: inboxID }).pipe(Effect.catchTag("SessionInbox.LifecycleConflict", () => Effect.gen(function* () {
+    yield* get(sessionID);
+    return yield* new InboxConflictError2({ sessionID, inboxID });
+  })));
+  const inbox = Effect.fn("Session.inbox")(function* (sessionID) {
+    yield* get(sessionID);
+    return yield* admission.list(sessionID);
+  });
+  const cancelInbox = Effect.fn("Session.cancelInbox")((sessionID, inboxID) => mutatePending(sessionID, inboxID, admission.cancel), Effect.uninterruptible);
+  const steerInbox = Effect.fn("Session.steerInbox")(function* (sessionID, inboxID) {
+    yield* mutatePending(sessionID, inboxID, admission.steer);
+    yield* execution.wake(sessionID);
+  }, Effect.uninterruptible);
+  const queueInbox = Effect.fn("Session.queueInbox")((sessionID, inboxID) => mutatePending(sessionID, inboxID, admission.queue), Effect.uninterruptible);
+  const prompt = Effect.fn("Session.prompt")((sessionID, input) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+    const session = yield* get(sessionID);
+    const messageID = input.id ?? SessionMessage2.ID.create();
+    const admitted = yield* Effect.gen(function* () {
+      const existing = yield* admission.reconcile({
+        id: messageID,
+        sessionID: session.id,
+        type: "user",
+        delivery: input.delivery ?? "steer"
+      });
+      if (existing)
+        return existing;
+      const item = yield* restore(prepare2({ session, messageID, input }).pipe(Effect.provideService(Service42, instances), Effect.provideService(FSUtil.Service, fs)));
+      if (session.revert)
+        yield* commit2(bus, session);
+      return yield* admission.admit({
+        id: messageID,
+        sessionID: session.id,
+        item
+      });
+    }).pipe(Effect.catchTag("SessionInbox.LifecycleConflict", () => new PromptConflictError2({ sessionID, messageID })));
+    if (input.resume !== false)
+      yield* execution.wake(sessionID);
+    return admitted;
+  })));
+  const shell = Effect.fn("Session.shell")(function* (sessionID, input) {
+    const session = yield* get(sessionID);
+    const running = yield* Effect.gen(function* () {
+      const started = yield* start2({ session, command: input.command }).pipe(Effect.provideService(Service42, instances), Effect.tapError((error) => synthetic(sessionID, {
+        text: `User shell command failed to start:
+${input.command}
+
+${error.message}`,
+        description: input.command,
+        metadata: { source: "shell", state: "error" },
+        resume: false
+      })), Effect.orDie);
+      yield* bus.publish(SessionEvent2.Shell.Started, {
+        sessionID,
+        shell: started.info
+      }, { id: input.id });
+      const terminal = yield* started.result;
+      const preview = yield* started.output;
+      yield* bus.publish(SessionEvent2.Shell.Ended, {
+        sessionID,
+        shell: terminal.info,
+        output: preview
+      });
+      yield* synthetic(sessionID, {
+        ...userNotification2(terminal),
+        resume: false
+      }).pipe(Effect.catchTag("Session.NotFoundError", () => Effect.void), Effect.orDie);
+    }).pipe(Effect.forkIn(scope, { startImmediately: true }));
+    yield* Fiber.join(running);
+  });
+  const skill = Effect.fn("Session.skill")(function* (sessionID, input) {
+    const session = yield* get(sessionID);
+    const skill = yield* get4({ session, skill: input.skill }).pipe(Effect.provideService(Service42, instances));
+    yield* bus.publish(SessionEvent2.Skill.Activated, {
+      sessionID,
+      id: skill.id,
+      name: skill.name,
+      text: skill.content
+    }, { id: input.id ? Event.ID.make(input.id.replace(/^msg_/, "evt_")) : undefined });
+    if (input.resume !== false)
+      yield* execution.resume(sessionID).pipe(Effect.ignore, Effect.forkIn(scope, { startImmediately: true }), Effect.asVoid);
+  });
+  const compact = Effect.fn("Session.compact")(function* (sessionID, input) {
+    const session = yield* get(sessionID);
+    if (session.revert)
+      yield* commit2(bus, session);
+    const inputID = input.id ?? SessionMessage2.ID.create();
+    const admitted = yield* admission.admitCompaction({
+      id: inputID,
+      sessionID,
+      delivery: input.delivery ?? "steer"
+    }).pipe(Effect.catchTag("SessionInbox.LifecycleConflict", () => new CompactionConflictError2({ sessionID, inputID })));
+    yield* execution.wake(sessionID);
+    return admitted;
+  });
+  const wait = Effect.fn("Session.wait")(function* (sessionID) {
+    yield* get(sessionID);
+    yield* execution.awaitIdle(sessionID);
+  });
+  const resume = Effect.fn("Session.resume")(function* (sessionID) {
+    yield* get(sessionID);
+    yield* execution.resume(sessionID);
+  });
+  const synthetic = Effect.fn("Session.synthetic")((sessionID, input) => Effect.uninterruptible(Effect.gen(function* () {
+    yield* get(sessionID);
+    const inputID = input.id ?? SessionMessage2.ID.create();
+    const admittedInput = {
+      type: "synthetic",
+      payload: SyntheticPayload2.make({
+        text: input.text,
+        description: input.description,
+        metadata: input.metadata
+      }),
+      delivery: Delivery2.make(input.delivery ?? "steer")
+    };
+    const admitted = yield* admission.admit({
+      id: inputID,
+      sessionID,
+      item: admittedInput
+    }).pipe(Effect.catchTag("SessionInbox.LifecycleConflict", () => new SyntheticConflictError2({ sessionID, inputID })));
+    if (input.resume !== false && !(yield* get(sessionID)).revert)
+      yield* execution.wake(sessionID);
+    return admitted;
+  })));
+  const interrupt = Effect.fn("Session.interrupt")((sessionID, options) => Effect.uninterruptible(execution.interrupt(sessionID, options)));
+  const stage = Effect.fn("Session.revert.stage")(function* (sessionID, input) {
+    const session = yield* get(sessionID);
+    if (yield* execution.isActive(sessionID))
+      return yield* new BusyError2({ sessionID });
+    return yield* stage2({ session, messageID: input.messageID, files: input.files }).pipe(Effect.provideService(Service42, instances), Effect.provideService(Service80, database), Effect.provideService(Service79, bus));
+  });
+  const clear = Effect.fn("Session.revert.clear")(function* (sessionID) {
+    const session = yield* get(sessionID);
+    if (yield* execution.isActive(sessionID))
+      return yield* new BusyError2({ sessionID });
+    yield* clear2(session).pipe(Effect.provideService(Service42, instances), Effect.provideService(Service79, bus));
+    return yield* execution.wake(sessionID);
+  });
+  const commit = Effect.fn("Session.revert.commit")(function* (sessionID) {
+    const session = yield* get(sessionID);
+    if (yield* execution.isActive(sessionID))
+      return yield* new BusyError2({ sessionID });
+    return yield* commit2(bus, session);
+  });
+  const revert = { stage, clear, commit };
+  const operations = {
+    get,
+    message,
+    view,
+    rename,
+    setPermissions,
+    switchAgent,
+    switchModel,
+    inbox,
+    prompt,
+    synthetic,
+    shell,
+    skill,
+    compact,
+    wait,
+    resume,
+    interrupt,
+    cancelInbox,
+    steerInbox,
+    queueInbox,
+    revert
+  };
+  const forSession = (sessionID) => {
+    const get = operations.get.bind(undefined, sessionID);
+    const message = operations.message.bind(undefined, sessionID);
+    const view = operations.view.bind(undefined, sessionID);
+    const rename = operations.rename.bind(undefined, sessionID);
+    const setPermissions = operations.setPermissions.bind(undefined, sessionID);
+    const switchAgent = operations.switchAgent.bind(undefined, sessionID);
+    const switchModel = operations.switchModel.bind(undefined, sessionID);
+    const inbox = operations.inbox.bind(undefined, sessionID);
+    const prompt = operations.prompt.bind(undefined, sessionID);
+    const synthetic = operations.synthetic.bind(undefined, sessionID);
+    const shell = operations.shell.bind(undefined, sessionID);
+    const skill = operations.skill.bind(undefined, sessionID);
+    const compact = operations.compact.bind(undefined, sessionID);
+    const wait = operations.wait.bind(undefined, sessionID);
+    const resume = operations.resume.bind(undefined, sessionID);
+    const interrupt = operations.interrupt.bind(undefined, sessionID);
+    const cancelInbox = operations.cancelInbox.bind(undefined, sessionID);
+    const steerInbox = operations.steerInbox.bind(undefined, sessionID);
+    const queueInbox = operations.queueInbox.bind(undefined, sessionID);
+    const stage = operations.revert.stage.bind(undefined, sessionID);
+    const clear = operations.revert.clear.bind(undefined, sessionID);
+    const commit = operations.revert.commit.bind(undefined, sessionID);
+    const revert = { stage, clear, commit };
+    return {
+      id: sessionID,
+      get,
+      message,
+      view,
+      rename,
+      setPermissions,
+      switchAgent,
+      switchModel,
+      inbox,
+      prompt,
+      synthetic,
+      shell,
+      skill,
+      compact,
+      wait,
+      resume,
+      interrupt,
+      cancelInbox,
+      steerInbox,
+      queueInbox,
+      revert
+    };
+  };
+  return { forSession };
+});
+
+export { make12, exports_session2 };