@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-maw26xhb.js

@@ -0,0 +1,81 @@
+import {
+  exports_skill
+} from "./ripgrep-p5bd5gkc.js";
+import {
+  exports_instructions
+} from "./ripgrep-8k8ks5a6.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/skill/instructions.ts
+var exports_instructions2 = {};
+__export(exports_instructions2, {
+  node: () => node,
+  SkillInstructions: () => exports_instructions2,
+  Service: () => Service
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+var Summary = Schema.Struct({
+  id: exports_skill.ID,
+  name: exports_skill.Name,
+  description: Schema.String
+});
+var entries = (skills) => skills.flatMap((skill) => [
+  "  <skill>",
+  `    <id>${skill.id}</id>`,
+  `    <name>${skill.name}</name>`,
+  `    <description>${skill.description}</description>`,
+  "  </skill>"
+]);
+var render = (skills) => [
+  "Skills provide specialized instructions and workflows for specific tasks.",
+  "Use the skill tool to load a skill when a task matches its description.",
+  ...skills.length === 0 ? ["No skills are currently available."] : ["<available_skills>", ...entries(skills), "</available_skills>"]
+].join(`
+`);
+var update = (previous, current) => {
+  const diff = exports_instructions.diffByKey(previous, current, (skill) => skill.id, (before, after) => before.name !== after.name || before.description !== after.description);
+  if (diff.changed.length > 0 || diff.added.length === 0 && diff.removed.length === 0)
+    return [
+      "The available skills have changed. This list supersedes the previous available skills list.",
+      render(current)
+    ].join(`
+`);
+  return [
+    ...diff.added.length === 0 ? [] : ["New skills are available in addition to those previously listed:", ...entries(diff.added)],
+    ...diff.removed.length === 0 ? [] : [
+      `The following skill IDs are no longer available and must not be used: ${diff.removed.map((skill) => skill.id).join(", ")}.`
+    ]
+  ].join(`
+`);
+};
+
+class Service extends Context.Service()("@opencode/SkillInstructions") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const skills = yield* exports_skill.Service;
+  return Service.of({
+    load: Effect.fn("SkillInstructions.load")(function* (selection) {
+      const agent = selection.info;
+      if (!agent)
+        return exports_instructions.empty;
+      const permitted = exports_skill.available(yield* skills.list(), agent);
+      const available = permitted.flatMap((skill) => skill.description === undefined || skill.autoinvoke === false ? [] : [{ id: skill.id, name: skill.name, description: skill.description }]).toSorted((a, b) => a.id.localeCompare(b.id));
+      return exports_instructions.make({
+        key: exports_instructions.Key.make("core/skill-guidance"),
+        codec: Schema.toCodecJson(Schema.Array(Summary)),
+        read: Effect.succeed(available.length === 0 ? exports_instructions.removed : available),
+        render: {
+          initial: render,
+          changed: update,
+          removed: () => "Skill guidance is no longer available. Do not use any previously listed skill."
+        }
+      });
+    })
+  });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [exports_skill.node] });
+
+export { Service, node, exports_instructions2 as exports_instructions };

package/dist/chunks/ripgrep-mddqbz23.js

@@ -0,0 +1,131 @@
+import {
+  exports_config
+} from "./ripgrep-rz9mfttk.js";
+import {
+  exports_provider
+} from "./ripgrep-d6vvk673.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/config/plugin/provider.ts
+var exports_provider2 = {};
+__export(exports_provider2, {
+  Plugin: () => Plugin,
+  ConfigProviderPlugin: () => exports_provider2
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Money } from "@opencode-ai/schema/money";
+import { Effect, Stream } from "effect";
+var Plugin = define({
+  id: "opencode.config.provider",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* exports_config.Service;
+    const loaded = { entries: yield* config.entries() };
+    yield* ctx.integration.transform((integrations) => {
+      for (const [id, provider] of configuredProviders(loaded.entries)) {
+        const integrationID = id;
+        if (!integrations.get(integrationID)) {
+          integrations.method.update({
+            integrationID,
+            method: { type: "key", label: "Manually enter API Key" }
+          });
+        }
+        integrations.update(integrationID, (integration) => {
+          integration.name = provider.name ?? integration.name;
+        });
+        if (provider.env !== undefined) {
+          integrations.method.update({
+            integrationID,
+            method: { type: "env", names: [...provider.env] }
+          });
+        }
+      }
+    });
+    yield* ctx.catalog.transform((catalog) => {
+      const configuredDefault = exports_config.latest(loaded.entries, "model");
+      if (configuredDefault !== undefined)
+        catalog.model.default.set(configuredDefault.providerID, configuredDefault.model);
+      for (const [id, item] of configuredProviders(loaded.entries)) {
+        const providerID = id;
+        catalog.provider.update(providerID, (provider) => {
+          provider.activation = "enabled";
+          if (item.name !== undefined)
+            provider.name = item.name;
+          if (item.package !== undefined)
+            provider.package = item.package;
+          if (item.settings !== undefined)
+            provider.settings = exports_provider.mergeOverlay(provider.settings, item.settings);
+          if (item.headers !== undefined)
+            provider.headers = exports_provider.mergeHeaders(provider.headers, item.headers);
+          if (item.body !== undefined)
+            provider.body = exports_provider.mergeOverlay(provider.body, item.body);
+        });
+        for (const [id2, config2] of Object.entries(item.models ?? {})) {
+          catalog.model.update(providerID, id2, (model) => {
+            if (config2.family !== undefined)
+              model.family = config2.family;
+            if (config2.name !== undefined)
+              model.name = config2.name;
+            if (config2.modelID !== undefined)
+              model.modelID = config2.modelID;
+            if (config2.compatibility !== undefined)
+              model.compatibility = { ...model.compatibility, ...config2.compatibility };
+            if (config2.package !== undefined)
+              model.package = config2.package;
+            if (config2.settings !== undefined)
+              model.settings = exports_provider.mergeOverlay(model.settings, config2.settings);
+            if (config2.headers !== undefined)
+              model.headers = exports_provider.mergeHeaders(model.headers, config2.headers);
+            if (config2.body !== undefined)
+              model.body = exports_provider.mergeOverlay(model.body, config2.body);
+            if (config2.capabilities !== undefined) {
+              model.capabilities = {
+                tools: config2.capabilities.tools,
+                input: [...config2.capabilities.input],
+                output: [...config2.capabilities.output]
+              };
+            }
+            if (config2.variants !== undefined) {
+              model.variants ??= [];
+              for (const variant of config2.variants) {
+                let existing = model.variants.find((item2) => item2.id === variant.id);
+                if (!existing) {
+                  existing = { id: variant.id };
+                  model.variants.push(existing);
+                }
+                if (variant.settings !== undefined)
+                  existing.settings = exports_provider.mergeOverlay(existing.settings, variant.settings);
+                if (variant.headers !== undefined)
+                  existing.headers = exports_provider.mergeHeaders(existing.headers, variant.headers);
+                if (variant.body !== undefined)
+                  existing.body = exports_provider.mergeOverlay(existing.body, variant.body);
+              }
+            }
+            if (config2.cost !== undefined) {
+              model.cost = (Array.isArray(config2.cost) ? config2.cost : [config2.cost]).map((cost) => ({
+                tier: cost.tier && { ...cost.tier },
+                input: cost.input,
+                output: cost.output,
+                cache: {
+                  read: cost.cache?.read ?? Money.USDPerMillionTokens.zero,
+                  write: cost.cache?.write ?? Money.USDPerMillionTokens.zero
+                }
+              }));
+            }
+            if (config2.disabled !== undefined)
+              model.enabled = !config2.disabled;
+            if (config2.limit !== undefined)
+              model.limit = { ...model.limit, ...config2.limit };
+          });
+        }
+      }
+    });
+    yield* ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(() => config.entries().pipe(Effect.tap((entries) => Effect.sync(() => loaded.entries = entries)), Effect.andThen(ctx.integration.reload()), Effect.andThen(ctx.catalog.reload()))), Effect.forkScoped({ startImmediately: true }));
+  })
+});
+function configuredProviders(entries) {
+  return entries.filter((entry) => entry.type === "document").flatMap((file) => Object.entries(file.info.providers ?? {}));
+}
+
+export { Plugin, exports_provider2 as exports_provider };

package/dist/chunks/ripgrep-mf0hyk7z.js

@@ -0,0 +1,18 @@
+import {
+  Timestamps
+} from "./ripgrep-sem2g21k.js";
+
+// src/credential/sql.ts
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+var CredentialTable = sqliteTable("credential", {
+  id: text().$type().primaryKey(),
+  integration_id: text().$type(),
+  label: text().notNull(),
+  value: text({ mode: "json" }).$type().notNull(),
+  connector_id: text(),
+  method_id: text(),
+  active: integer({ mode: "boolean" }),
+  ...Timestamps
+});
+
+export { CredentialTable };

package/dist/chunks/ripgrep-mh28new4.js

@@ -0,0 +1,17 @@
+import {
+  ProjectTable
+} from "./ripgrep-88jbfw8z.js";
+import {
+  absoluteColumn
+} from "./ripgrep-zbqqnp0n.js";
+
+// src/worktree/sql.ts
+import { integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
+var WorktreeTable = sqliteTable("worktree", {
+  project_id: text().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+  directory: absoluteColumn().notNull(),
+  strategy: text(),
+  time_created: integer().notNull().$default(() => Date.now())
+}, (table) => [primaryKey({ columns: [table.project_id, table.directory] })]);
+
+export { WorktreeTable };

package/dist/chunks/ripgrep-mnq2dj4r.js

@@ -0,0 +1,12 @@
+import {
+  migrate
+} from "./ripgrep-fb5qgyky.js";
+
+// src/database/drizzle/effect-sqlite/migrator.ts
+import { readMigrationFiles } from "drizzle-orm/migrator";
+function migrate2(db, config) {
+  const migrations = readMigrationFiles(config);
+  return migrate(migrations, db.session, config);
+}
+
+export { migrate2 as migrate };

package/dist/chunks/ripgrep-mwceq5am.js

@@ -0,0 +1,102 @@
+import {
+  getViewSelectedFieldsRuntime,
+  orderSelectedFields
+} from "./ripgrep-ma07p6tt.js";
+
+// src/database/drizzle/sqlite-core/effect/select.ts
+import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
+import { entityKind, is } from "drizzle-orm/entity";
+import { SQL } from "drizzle-orm/sql/sql";
+import { SQLiteSelectQueryBuilderBase } from "drizzle-orm/sqlite-core/query-builders/select";
+import { SQLiteViewBase } from "drizzle-orm/sqlite-core/view-base";
+import { Subquery } from "drizzle-orm/subquery";
+import { getTableColumns } from "drizzle-orm/utils";
+class SQLiteEffectSelectBuilder {
+  static [entityKind] = "SQLiteEffectSelectBuilder";
+  fields;
+  session;
+  dialect;
+  withList;
+  distinct;
+  constructor(config) {
+    this.fields = config.fields;
+    this.session = config.session;
+    this.dialect = config.dialect;
+    this.withList = config.withList;
+    this.distinct = config.distinct;
+  }
+  from(source) {
+    const isPartialSelect = !!this.fields;
+    let fields;
+    if (this.fields) {
+      fields = this.fields;
+    } else if (is(source, Subquery)) {
+      fields = Object.fromEntries(Object.keys(source._.selectedFields).map((key) => [
+        key,
+        source[key]
+      ]));
+    } else if (is(source, SQLiteViewBase)) {
+      fields = getViewSelectedFieldsRuntime(source).selectedFields;
+    } else if (is(source, SQL)) {
+      fields = {};
+    } else {
+      fields = getTableColumns(source);
+    }
+    return new SQLiteEffectSelectBase({
+      table: source,
+      fields,
+      isPartialSelect,
+      session: this.session,
+      dialect: this.dialect,
+      withList: this.withList,
+      distinct: this.distinct
+    });
+  }
+}
+
+class SQLiteEffectSelectBase extends SQLiteSelectQueryBuilderBase {
+  static [entityKind] = "SQLiteEffectSelect";
+  get effectConfig() {
+    return this.config;
+  }
+  getSQL() {
+    return this.dialect.buildSelectQuery(this.effectConfig);
+  }
+  _prepare(isOneTimeQuery = true) {
+    if (!this.session) {
+      throw new Error("Cannot execute a query on a query builder. Please use a database instance instead.");
+    }
+    const session = this.session;
+    const query = session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](this.dialect.sqlToQuery(this.getSQL()), orderSelectedFields(this.effectConfig.fields), "all", undefined, {
+      type: "select",
+      tables: [...this.usedTables]
+    }, this.cacheConfig);
+    query.joinsNotNullableMap = this.joinsNotNullableMap;
+    return query;
+  }
+  $withCache(config) {
+    this.cacheConfig = config === undefined ? { config: {}, enabled: true, autoInvalidate: true } : config === false ? { enabled: false } : { enabled: true, autoInvalidate: true, ...config };
+    return this;
+  }
+  prepare() {
+    return this._prepare(false);
+  }
+  run = (placeholderValues) => {
+    return this._prepare().run(placeholderValues);
+  };
+  all = (placeholderValues) => {
+    return this._prepare().all(placeholderValues);
+  };
+  get = (placeholderValues) => {
+    return this._prepare().get(placeholderValues);
+  };
+  values = (placeholderValues) => {
+    return this._prepare().values(placeholderValues);
+  };
+  execute = (placeholderValues) => {
+    return this._prepare().execute(placeholderValues);
+  };
+}
+applyEffectWrapper(SQLiteEffectSelectBase);
+
+export { SQLiteEffectSelectBuilder, SQLiteEffectSelectBase };

package/dist/chunks/ripgrep-mz3jaqv3.js

@@ -0,0 +1,222 @@
+import {
+  exports_mcp
+} from "./ripgrep-f37844cq.js";
+import {
+  exports_select
+} from "./ripgrep-04kwjb53.js";
+import {
+  exports_config
+} from "./ripgrep-rz9mfttk.js";
+import {
+  exports_location
+} from "./ripgrep-hcyadm03.js";
+import {
+  exports_state
+} from "./ripgrep-wt193r4g.js";
+import {
+  exports_bus
+} from "./ripgrep-6wnd6t4j.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/command.ts
+var exports_command = {};
+__export(exports_command, {
+  node: () => node,
+  layer: () => layer,
+  configured: () => configured,
+  Service: () => Service,
+  NotFoundError: () => NotFoundError,
+  Info: () => Info,
+  Event: () => Event,
+  EvaluationError: () => EvaluationError,
+  Command: () => exports_command
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Command } from "@opencode-ai/schema/command";
+import { AppProcess } from "@opencode-ai/util/process";
+import { ChildProcess } from "effect/unstable/process";
+import { Global } from "@opencode-ai/util/global";
+import { Event } from "@opencode-ai/schema/command";
+var Info = Command.Info;
+
+class NotFoundError extends Schema.TaggedErrorClass()("Command.NotFoundError", {
+  command: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class EvaluationError extends Schema.TaggedErrorClass()("Command.EvaluationError", {
+  command: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class Service extends Context.Service()("@opencode/Command") {
+}
+var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
+  const mcp = yield* exports_mcp.Service;
+  const bus = yield* exports_bus.Service;
+  const processes = yield* AppProcess.Service;
+  const config = yield* exports_config.Service;
+  const location = yield* exports_location.Service;
+  const global = yield* Global.Service;
+  const state = exports_state.create({
+    name: "command",
+    initial: () => ({ commands: new Map }),
+    draft: (draft) => ({
+      list: () => Array.from(draft.commands.values()),
+      get: (name) => draft.commands.get(name),
+      update: (name, update) => {
+        const current = draft.commands.get(name) ?? { name, template: "" };
+        if (!draft.commands.has(name))
+          draft.commands.set(name, current);
+        update(current);
+        current.name = name;
+      },
+      remove: (name) => {
+        draft.commands.delete(name);
+      }
+    }),
+    finalize: () => bus.publish(Command.Event.Updated, {}).pipe(Effect.asVoid)
+  });
+  const staticCommand = (name) => state.get().commands.get(name);
+  const mcpCommands = Effect.fnUntraced(function* () {
+    return (yield* mcp.prompts()).map((prompt) => Info.make({
+      name: mcpCommandName(prompt.server, prompt.name),
+      template: "",
+      description: prompt.description
+    }));
+  });
+  return Service.of({
+    reload: state.reload,
+    transform: state.transform,
+    get: Effect.fn("Command.get")(function* (name) {
+      const command = staticCommand(name);
+      if (command)
+        return command;
+      return (yield* mcpCommands()).find((command2) => command2.name === name);
+    }),
+    list: Effect.fn("Command.list")(function* () {
+      const commands = Array.from(state.get().commands.values());
+      const names = new Set(commands.map((command) => command.name));
+      return [...commands, ...(yield* mcpCommands()).filter((command) => !names.has(command.name))];
+    }),
+    evaluate: Effect.fn("Command.evaluate")(function* (input) {
+      const command = staticCommand(input.name);
+      if (command)
+        return yield* evaluateTemplate(input.name, command.template, input.arguments ?? "", {
+          config,
+          location,
+          processes,
+          shell: options,
+          bin: global.bin
+        });
+      const prompt = (yield* mcp.prompts()).find((prompt2) => mcpCommandName(prompt2.server, prompt2.name) === input.name);
+      if (!prompt)
+        return yield* new NotFoundError({ command: input.name, message: `Command not found: ${input.name}` });
+      const result = yield* mcp.prompt({
+        server: prompt.server,
+        name: prompt.name,
+        args: Object.fromEntries((prompt.arguments ?? []).map((argument, index) => [
+          argument.name,
+          parseArguments(input.arguments ?? "")[index] ?? ""
+        ]))
+      }).pipe(Effect.catchTag("MCP.NotFoundError", () => Effect.fail(new EvaluationError({
+        command: input.name,
+        message: `MCP server could not be found while evaluating prompt: ${prompt.server}`
+      }))));
+      if (!result)
+        return yield* new EvaluationError({
+          command: input.name,
+          message: `MCP prompt could not be evaluated: ${prompt.server}:${prompt.name}`
+        });
+      return {
+        text: result.messages.map((message) => promptMessageText(message.content)).join(`
+`).trim()
+      };
+    })
+  });
+}));
+function evaluateTemplate(command, template, input, services) {
+  return Effect.gen(function* () {
+    const expanded = evaluateArguments(template, input);
+    return { text: yield* evaluateShell(command, expanded, services) };
+  });
+}
+function evaluateArguments(template, input) {
+  const args = parseArguments(input);
+  const placeholders = template.match(placeholderRegex) ?? [];
+  const last = Math.max(0, ...placeholders.map((item) => Number(item.slice(1))));
+  const expanded = template.replaceAll(placeholderRegex, (_, index) => {
+    const position = Number(index);
+    const argIndex = position - 1;
+    if (argIndex >= args.length)
+      return "";
+    if (position === last)
+      return args.slice(argIndex).join(" ");
+    return args[argIndex];
+  });
+  const withArguments = expanded.replaceAll("$ARGUMENTS", input);
+  if (placeholders.length === 0 && !template.includes("$ARGUMENTS") && input.trim())
+    return `${withArguments}
+
+${input}`.trim();
+  return withArguments.trim();
+}
+var evaluateShell = Effect.fnUntraced(function* (command, text, services) {
+  const matches = Array.from(text.matchAll(shellRegex));
+  if (matches.length === 0)
+    return text;
+  const shell = exports_select.preferred(exports_config.latest(yield* services.config.entries(), "shell"), services.shell, services.bin);
+  const outputs = yield* Effect.forEach(matches, (match) => {
+    const source = match[1] ?? "";
+    return services.processes.run(ChildProcess.make(shell, exports_select.args(shell, source), {
+      cwd: services.location.directory,
+      stdin: "ignore"
+    }), {
+      combineOutput: true
+    }).pipe(Effect.map((result) => (result.output ?? Buffer.concat([result.stdout, result.stderr])).toString("utf8")), Effect.mapError((error) => new EvaluationError({
+      command,
+      message: `Shell interpolation failed for ${JSON.stringify(source)}: ${error.message}`
+    })));
+  }, { concurrency: 2 });
+  const iterator = outputs[Symbol.iterator]();
+  return text.replace(shellRegex, () => iterator.next().value ?? "");
+});
+function parseArguments(input) {
+  return (input.match(argsRegex) ?? []).map((arg) => arg.replace(quoteTrimRegex, ""));
+}
+function promptMessageText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!content || typeof content !== "object")
+    return "";
+  if (!("type" in content) || content.type !== "text")
+    return "";
+  if (!("text" in content) || typeof content.text !== "string")
+    return "";
+  return content.text;
+}
+function mcpCommandName(server, prompt) {
+  return `${sanitize(server)}:${sanitize(prompt)}`;
+}
+function sanitize(value) {
+  return value.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+var argsRegex = /(?:\[Image\s+\d+\]|"[^"]*"|'[^']*'|[^\s"']+)/gi;
+var placeholderRegex = /\$(\d+)/g;
+var quoteTrimRegex = /^["']|["']$/g;
+var shellRegex = /!`([^`]+)`/g;
+function configured(options) {
+  return makeLocationNode({
+    service: Service,
+    layer: layer(options),
+    deps: [exports_mcp.node, exports_bus.node, AppProcess.node, exports_config.node, exports_location.node, Global.node]
+  });
+}
+var node = configured();
+
+export { Info, NotFoundError, EvaluationError, Service, layer, configured, node, exports_command, Event };

package/dist/chunks/ripgrep-n3m50c2t.js

@@ -0,0 +1,15 @@
+// src/database/migration/20260309230000_move_org_to_state.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260309230000_move_org_to_state",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`account_state\` ADD \`active_org_id\` text;`);
+      yield* tx.run(`UPDATE \`account_state\` SET \`active_org_id\` = (SELECT \`selected_org_id\` FROM \`account\` WHERE \`account\`.\`id\` = \`account_state\`.\`active_account_id\`);`);
+      yield* tx.run(`ALTER TABLE \`account\` DROP COLUMN \`selected_org_id\`;`);
+    });
+  }
+};
+var _20260309230000_move_org_to_state_default = migration;
+
+export { _20260309230000_move_org_to_state_default };