@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-8vg4n516.js

@@ -0,0 +1,164 @@
+import {
+  ID9
+} from "./repository-b5n11jz6.js";
+import {
+  AbsolutePath2
+} from "./repository-922hggd3.js";
+import {
+  Info13
+} from "./repository-za4pw5w1.js";
+import {
+  migrateAgent2
+} from "./repository-pwf15mvc.js";
+import {
+  latest2,
+  Service44
+} from "./repository-smnv2tch.js";
+import {
+  parseOption2
+} from "./repository-5daktx2q.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/config/plugin/agent.ts
+var exports_agent = {};
+__export(exports_agent, {
+  ConfigAgentPlugin: () => exports_agent,
+  Plugin: () => Plugin9
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Document, Info } from "@opencode/schema/config";
+import { ConfigAgent } from "@opencode/schema/config/agent";
+import path from "path";
+import { Effect, Option, PubSub, Schema, Stream } from "effect";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+var legacySources = [
+  { pattern: "{agent,agents}/**/*.md", primary: false },
+  { pattern: "{mode,modes}/*.md", primary: true }
+];
+var sourceDirectories = ["agent", "agents", "mode", "modes"];
+var decodeAgent = Schema.decodeUnknownOption(ConfigAgent.Info);
+var decodeLegacyAgent = Schema.decodeUnknownOption(Info13);
+var decodeConfig = Schema.decodeUnknownOption(Info);
+var pathActions = ["external_directory", "read", "edit"];
+var agentKeys = new Set(["variant", ...Object.keys(ConfigAgent.Info.fields)]);
+var Plugin9 = define({
+  id: "opencode.config.agent",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service44;
+    const fs = yield* FSUtil.Service;
+    const global = yield* Global.Service;
+    const loadEntry = Effect.fnUntraced(function* (entry) {
+      if (entry.type === "document")
+        return [entry];
+      if (entry.type !== "directory")
+        return [];
+      const files = yield* discover(fs, entry.path);
+      return yield* Effect.forEach(files, (file) => fs.readFileStringSafe(file.filepath).pipe(Effect.map((content) => content ? decode(file, content) : undefined), Effect.orElseSucceed(() => {
+        return;
+      }))).pipe(Effect.map((documents) => documents.filter((document) => document !== undefined)));
+    });
+    const load = Effect.fn("ConfigAgentPlugin.load")(function* () {
+      return yield* Effect.forEach(yield* config.entries(), loadEntry).pipe(Effect.map((documents) => documents.flat()));
+    });
+    const loaded = { documents: [] };
+    const reload = load().pipe(Effect.tap((documents) => Effect.sync(() => loaded.documents = documents)), Effect.andThen(ctx.agent.reload()));
+    const changes = yield* PubSub.sliding(1);
+    const notify = () => PubSub.publish(changes, undefined);
+    yield* config.changes().pipe(Stream.filterEffect((update) => Effect.map(config.entries(), (entries) => isAgentSource(entries, update.path))), Stream.runForEach(notify), Effect.forkScoped({ startImmediately: true }));
+    yield* ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(notify), Effect.forkScoped({ startImmediately: true }));
+    const updates = yield* PubSub.subscribe(changes);
+    yield* Stream.fromSubscription(updates).pipe(Stream.debounce("100 millis"), Stream.runForEach(() => reload), Effect.forkScoped({ startImmediately: true }));
+    loaded.documents = yield* load();
+    yield* ctx.agent.transform((editor) => {
+      const permissions = expandPermissions(loaded.documents.flatMap((document) => document.info.permissions ?? []), global.home);
+      const configuredDefault = latest2(loaded.documents, "default_agent");
+      if (configuredDefault !== undefined)
+        editor.default(ID9.make(configuredDefault));
+      for (const current of editor.list()) {
+        editor.update(current.id, (agent) => agent.permissions.push(...permissions));
+      }
+      for (const document of loaded.documents) {
+        for (const [id, item] of Object.entries(document.info.agents ?? {})) {
+          const agentID = ID9.make(id);
+          if (item.disabled) {
+            editor.remove(agentID);
+            continue;
+          }
+          const exists = editor.get(agentID) !== undefined;
+          editor.update(agentID, (agent) => {
+            if (!exists)
+              agent.permissions.push(...permissions);
+            if (item.model !== undefined)
+              agent.model = {
+                id: item.model.model,
+                providerID: item.model.providerID,
+                ...item.model.variant === undefined ? {} : { variant: item.model.variant }
+              };
+            if (item.request !== undefined) {
+              Object.assign(agent.request.headers, item.request.headers ?? {});
+              Object.assign(agent.request.body, item.request.body ?? {});
+            }
+            if (item.system !== undefined)
+              agent.system = item.system;
+            if (item.description !== undefined)
+              agent.description = item.description;
+            if (item.mode !== undefined)
+              agent.mode = item.mode;
+            if (item.hidden !== undefined)
+              agent.hidden = item.hidden;
+            if (item.color !== undefined)
+              agent.color = item.color;
+            if (item.steps !== undefined)
+              agent.steps = item.steps;
+            if (item.permissions !== undefined) {
+              agent.permissions.push(...expandPermissions(item.permissions, global.home));
+            }
+          });
+        }
+      }
+    });
+  })
+});
+function isAgentSource(entries, file) {
+  return entries.some((entry) => entry.type === "directory" && sourceDirectories.some((name) => FSUtil.contains(path.join(entry.path, name), file)));
+}
+function expandPermissions(rules, home) {
+  return rules.map((rule) => isPathAction(rule.action) ? { ...rule, resource: expandHome(rule.resource, home) } : rule);
+}
+function isPathAction(action) {
+  return pathActions.some((item) => item === action);
+}
+function expandHome(resource, home) {
+  if (resource === "~" || resource === "$HOME")
+    return home;
+  const relative = resource.startsWith("~/") ? resource.slice(2) : resource.startsWith("$HOME/") || resource.startsWith("$HOME\\") ? resource.slice(6) : undefined;
+  if (relative !== undefined)
+    return (path.posix.isAbsolute(home) ? path.posix : path.win32).join(home, relative);
+  return resource;
+}
+function discover(fs, directory) {
+  return Effect.forEach(legacySources, (source) => fs.scan(source.pattern, { cwd: directory, absolute: true, dot: true, symlink: true }).pipe(Effect.map((files) => files.toSorted().map((filepath) => ({ directory, filepath, primary: source.primary }))))).pipe(Effect.map((files) => files.flat()), Effect.orElseSucceed(() => []));
+}
+function decode(file, content) {
+  const markdown = parseOption2(content);
+  if (!markdown)
+    return;
+  const name = path.relative(file.directory, file.filepath).replaceAll("\\", "/").replace(/^(agent|agents|mode|modes)\//, "").replace(/\.md$/, "");
+  const body = markdown.content.trim();
+  const legacy = Object.keys(markdown.data).some((key) => !agentKeys.has(key));
+  const data = typeof markdown.data.model === "string" && !markdown.data.model.includes("#") && typeof markdown.data.variant === "string" && /^[^#]+$/.test(markdown.data.variant) ? { ...markdown.data, model: `${markdown.data.model}#${markdown.data.variant}` } : markdown.data;
+  const agent = legacy ? Option.getOrUndefined(Option.map(decodeLegacyAgent({ name, ...markdown.data, prompt: body }, { errors: "all", propertyOrder: "original" }), migrateAgent2)) : Option.getOrUndefined(decodeAgent({ ...data, system: body }, { errors: "all", propertyOrder: "original" }));
+  if (!agent)
+    return;
+  const info = Option.getOrUndefined(decodeConfig({
+    agents: { [name]: file.primary ? { ...agent, mode: "primary" } : agent }
+  }));
+  if (!info)
+    return;
+  return new Document({ type: "document", path: AbsolutePath2.make(file.filepath), info });
+}
+
+export { Plugin9, exports_agent };

package/dist/chunks/repository-922hggd3.js

@@ -0,0 +1,21 @@
+// src/schema.ts
+import { Schema } from "effect";
+import {
+  AbsolutePath as AbsolutePath2,
+  DateTimeUtcFromMillis as DateTimeUtcFromMillis2,
+  NonNegativeInt as NonNegativeInt2,
+  optional as optional2,
+  PositiveInt as PositiveInt2,
+  RelativePath as RelativePath2,
+  statics as statics2
+} from "@opencode/schema/schema";
+function Newtype2() {
+  return (tag, schema) => {
+    class Base {
+    }
+    Object.setPrototypeOf(Base, schema.pipe(Schema.brand(tag)));
+    return Base;
+  };
+}
+
+export { AbsolutePath2, DateTimeUtcFromMillis2, NonNegativeInt2, optional2, PositiveInt2, RelativePath2, statics2, Newtype2 };

package/dist/chunks/repository-9a4afbnw.js

@@ -0,0 +1,17 @@
+// src/database/migration/20260622170816_reset_v2_session_state.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260622170816_reset_v2_session_state",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DELETE FROM \`session_context_epoch\`;`);
+      yield* tx.run(`DELETE FROM \`session_input\`;`);
+      yield* tx.run(`DELETE FROM \`session_message\`;`);
+      yield* tx.run(`DELETE FROM \`event\`;`);
+      yield* tx.run(`DELETE FROM \`event_sequence\`;`);
+    });
+  }
+};
+var _20260622170816_reset_v2_session_state_default = migration;
+
+export { _20260622170816_reset_v2_session_state_default };

package/dist/chunks/repository-9rqn6x4v.js

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+export { __export };

package/dist/chunks/repository-9rs4eqfv.js

@@ -0,0 +1,44 @@
+import {
+  Service66,
+  node70
+} from "./repository-6wjjjhy6.js";
+import {
+  Service36
+} from "./repository-jqh9b0xq.js";
+import {
+  Service18,
+  node22
+} from "./repository-cedwm630.js";
+import {
+  node18
+} from "./repository-qt3bdkqw.js";
+import {
+  node3
+} from "./repository-t59s3hhv.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/worktree/refresh.ts
+var exports_refresh = {};
+__export(exports_refresh, {
+  WorktreeRefresh: () => exports_refresh,
+  node: () => node2
+});
+import { Effect, Layer } from "effect";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+var layer = Layer.effectDiscard(Effect.gen(function* () {
+  const location = yield* Service66;
+  const plugins = yield* Service36;
+  const worktrees = yield* Service18;
+  if (location.workspaceID)
+    return;
+  yield* plugins.awaitActivation.pipe(Effect.andThen(worktrees.refresh()), Effect.catchCause((cause) => Effect.logWarning("worktree refresh failed", { cause })), Effect.forkScoped);
+}));
+var node2 = makeLocationNode({
+  name: "worktree-refresh",
+  layer,
+  deps: [node22, node70, node18, node3]
+});
+
+export { node2, exports_refresh };

package/dist/chunks/repository-9xb0s4b9.js

@@ -0,0 +1,117 @@
+import {
+  Service78,
+  node83
+} from "./repository-x6rcf4cj.js";
+import {
+  create3
+} from "./repository-kg06axw8.js";
+import {
+  evaluate2
+} from "./repository-ykpr0q7c.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/skill.ts
+var exports_skill5 = {};
+__export(exports_skill5, {
+  DirectorySource: () => DirectorySource2,
+  EmbeddedSource: () => EmbeddedSource2,
+  Event: () => Event9,
+  ID: () => ID5,
+  Info: () => Info7,
+  Name: () => Name2,
+  Service: () => Service40,
+  Skill: () => exports_skill5,
+  Source: () => Source3,
+  UrlSource: () => UrlSource2,
+  available: () => available2,
+  node: () => node45,
+  prepare: () => prepare3,
+  toModelOutput: () => toModelOutput3
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import path from "path";
+import { Context, Effect, Layer } from "effect";
+import { Skill } from "@opencode/schema/skill";
+import { Event as Event9 } from "@opencode/schema/skill";
+var DirectorySource2 = Skill.DirectorySource;
+var UrlSource2 = Skill.UrlSource;
+var EmbeddedSource2 = Skill.EmbeddedSource;
+var Source3 = Skill.Source;
+var Info7 = Skill.Info;
+var ID5 = Skill.ID;
+var Name2 = Skill.Name;
+var available2 = (skills, agent) => skills.filter((skill) => evaluate2("skill", skill.id, agent.permissions).effect !== "deny");
+var toModelOutput3 = (skill, files) => {
+  const directory = path.dirname(skill.location);
+  return [
+    `<skill_content name="${skill.name}">`,
+    `# Skill: ${skill.name}`,
+    "",
+    skill.content.trim(),
+    "",
+    `Base directory for this skill: ${directory}`,
+    "Relative paths in this skill (e.g., scripts/, reference/) are relative to this base directory.",
+    "Note: file list is sampled.",
+    "",
+    "<skill_files>",
+    ...files.map((file) => `<file>${file}</file>`),
+    "</skill_files>",
+    "</skill_content>"
+  ].join(`
+`);
+};
+var prepare3 = Effect.fn("Skill.prepare")(function* (fs, skill) {
+  const directory = path.dirname(skill.location);
+  const files = path.basename(skill.location) === "SKILL.md" ? (yield* fs.scan("**/*", { cwd: directory, absolute: true, include: "file", dot: true })).filter((file) => path.basename(file) !== "SKILL.md").toSorted().slice(0, 10) : [];
+  return {
+    directory,
+    output: toModelOutput3(skill, files)
+  };
+});
+
+class Service40 extends Context.Service()("@opencode/Skill") {
+}
+var layer = Layer.effect(Service40, Effect.gen(function* () {
+  const bus = yield* Service78;
+  const state = create3({
+    name: "skill",
+    initial: () => ({ skills: new Map }),
+    editor: (editor) => ({
+      list: () => Array.from(editor.skills.values()),
+      get: (id) => editor.skills.get(ID5.make(id)),
+      add: (skill) => {
+        editor.skills.set(skill.id, { ...skill });
+      },
+      update: (id, update) => {
+        const current = editor.skills.get(ID5.make(id));
+        if (!current)
+          return;
+        update(current);
+        current.id = ID5.make(id);
+      },
+      remove: (id) => {
+        editor.skills.delete(ID5.make(id));
+      }
+    }),
+    notify: () => bus.publish(Skill.Event.Updated, {}).pipe(Effect.asVoid)
+  });
+  return Service40.of({
+    transform: state.transform,
+    reload: state.reload,
+    get: Effect.fn("Skill.get")(function* (id) {
+      return state.get().skills.get(id);
+    }),
+    list: Effect.fn("Skill.list")(function* () {
+      return Array.from(state.get().skills.values());
+    })
+  });
+}));
+var node45 = makeLocationNode({
+  service: Service40,
+  layer,
+  deps: [node83]
+});
+
+export { DirectorySource2, UrlSource2, EmbeddedSource2, Source3, Info7, ID5, Name2, available2, toModelOutput3, prepare3, Service40, node45, exports_skill5, Event9 };