@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-gd4qta3r.js

@@ -0,0 +1,25 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/file-retention.ts
+var exports_file_retention = {};
+__export(exports_file_retention, {
+  FileRetention: () => exports_file_retention,
+  cleanup: () => cleanup3
+});
+import { Duration, Effect, Option } from "effect";
+var cleanup3 = Effect.fn("FileRetention.cleanup")(function* (fs, files, retention) {
+  const cutoff = Date.now() - Duration.toMillis(retention);
+  yield* Effect.forEach(files, (file) => Effect.gen(function* () {
+    const info = yield* fs.stat(file).pipe(Effect.orElseSucceed(() => {
+      return;
+    }));
+    const mtime = info && Option.getOrUndefined(info.mtime);
+    if (!mtime || mtime.getTime() >= cutoff)
+      return;
+    yield* fs.remove(file).pipe(Effect.ignore);
+  }), { concurrency: 8, discard: true });
+});
+
+export { cleanup3, exports_file_retention };

package/dist/chunks/repository-gdvy8fx6.js

@@ -0,0 +1,151 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/codemode/catalog.ts
+var exports_catalog = {};
+__export(exports_catalog, {
+  CodeModeCatalog: () => exports_catalog,
+  Summary: () => Summary2,
+  Tool: () => Tool3,
+  namespaceLine: () => namespaceLine2,
+  summarize: () => summarize2
+});
+import { Schema } from "effect";
+var Tool3 = Schema.Struct({
+  type: Schema.Literal("tool"),
+  name: Schema.String,
+  description: Schema.String,
+  signature: Schema.String,
+  pinned: Schema.optionalKey(Schema.Boolean)
+});
+var Listing = Schema.Struct({
+  path: Schema.String,
+  line: Schema.String
+});
+var NamespaceSummary = Schema.Struct({
+  name: Schema.String,
+  description: Schema.optionalKey(Schema.String),
+  count: Schema.Number,
+  entries: Schema.Array(Listing)
+});
+var Summary2 = Schema.Struct({
+  total: Schema.Number,
+  shown: Schema.Number,
+  namespaces: Schema.Array(NamespaceSummary)
+});
+var DESCRIPTION_LIMIT = 120;
+var CHARACTERS_PER_TOKEN = 4;
+var INLINE_BUDGET = 2000;
+function summarize2(inventory, options = {}) {
+  const budget = options.budget ?? INLINE_BUDGET;
+  const flattened = flatten(inventory.tools);
+  const namespaces = [...Map.groupBy(flattened.tools, (tool) => tool.path.split(".", 1)[0] ?? tool.path)].sort(([left], [right]) => {
+    if (left < right)
+      return -1;
+    if (left > right)
+      return 1;
+    return 0;
+  }).map(([name, namespaceEntries]) => {
+    const description = flattened.namespaces.get(name)?.description;
+    const listings = namespaceEntries.map((entry) => {
+      const firstLine = entry.description.split(`
+`, 1)[0]?.trim() ?? "";
+      const description = firstLine.length > DESCRIPTION_LIMIT ? firstLine.slice(0, DESCRIPTION_LIMIT - 3) + "..." : firstLine;
+      const suffix = description.length === 0 ? "" : ` // ${description}`;
+      return { path: entry.path, line: `  - ${entry.signature}${suffix}` };
+    }).toSorted((left, right) => {
+      if (left.path < right.path)
+        return -1;
+      if (left.path > right.path)
+        return 1;
+      return 0;
+    });
+    const ranked = rankListings(listings);
+    const pinned = new Set(namespaceEntries.filter((entry) => entry.pinned).map((entry) => listings.find((listing) => listing.path === entry.path)).filter((listing) => listing !== undefined));
+    return {
+      name,
+      ...description === undefined ? {} : { description },
+      listings,
+      selectionOrder: ranked.filter((candidate) => !pinned.has(candidate.listing)),
+      selectedListings: pinned,
+      selectionIndex: 0
+    };
+  });
+  const active = new Set(namespaces);
+  let remaining = budget - namespaces.reduce((total, namespace) => total + cost(namespaceLine2({
+    name: namespace.name,
+    ...namespace.description === undefined ? {} : { description: namespace.description },
+    count: namespace.listings.length,
+    entries: []
+  })), 0) - namespaces.flatMap((namespace) => namespace.listings.filter((listing) => namespace.selectedListings.has(listing))).reduce((total, listing) => total + cost(listing.line), 0);
+  while (active.size > 0) {
+    for (const namespace of active) {
+      const candidate = namespace.selectionOrder[namespace.selectionIndex];
+      if (!candidate || candidate.cost > remaining) {
+        active.delete(namespace);
+        continue;
+      }
+      namespace.selectedListings.add(candidate.listing);
+      namespace.selectionIndex += 1;
+      remaining -= candidate.cost;
+      if (namespace.selectionIndex === namespace.selectionOrder.length)
+        active.delete(namespace);
+    }
+  }
+  const namespaceSummaries = namespaces.map((namespace) => ({
+    name: namespace.name,
+    ...namespace.description === undefined ? {} : { description: namespace.description },
+    count: namespace.listings.length,
+    entries: namespace.listings.filter((listing) => namespace.selectedListings.has(listing))
+  }));
+  return {
+    total: flattened.tools.length,
+    shown: namespaceSummaries.reduce((total, namespace) => total + namespace.entries.length, 0),
+    namespaces: namespaceSummaries
+  };
+}
+function flatten(entries, path = []) {
+  const tools = [];
+  const namespaces = new Map;
+  for (const entry of entries) {
+    if (entry.type === "tool") {
+      tools.push({
+        type: "tool",
+        path: [...path, entry.name].join("."),
+        description: entry.description,
+        signature: entry.signature,
+        ...entry.pinned === undefined ? {} : { pinned: entry.pinned }
+      });
+      continue;
+    }
+    const next = [...path, entry.name];
+    namespaces.set(next.join("."), entry);
+    const nested = flatten(entry.tools, next);
+    tools.push(...nested.tools);
+    for (const [name, namespace] of nested.namespaces)
+      namespaces.set(name, namespace);
+  }
+  return { tools, namespaces };
+}
+function namespaceLine2(namespace) {
+  const count = namespace.count === 1 ? "1 tool" : `${namespace.count} tools`;
+  const label = namespace.entries.length === namespace.count ? count : namespace.entries.length === 0 ? `${count}, none shown` : `${count}, ${namespace.entries.length} shown`;
+  return `- ${namespace.name} (${label})${namespace.description === undefined ? "" : ` // ${namespace.description}`}`;
+}
+function rankListings(listings) {
+  return listings.map((listing) => ({ listing, cost: cost(listing.line) })).toSorted((left, right) => {
+    if (left.cost !== right.cost)
+      return left.cost - right.cost;
+    if (left.listing.path < right.listing.path)
+      return -1;
+    if (left.listing.path > right.listing.path)
+      return 1;
+    return 0;
+  });
+}
+function cost(text) {
+  return Math.round(text.length / CHARACTERS_PER_TOKEN);
+}
+
+export { Tool3, Summary2, summarize2, namespaceLine2, exports_catalog };

package/dist/chunks/repository-gebd4c9n.js

@@ -0,0 +1,77 @@
+// src/util/slug.ts
+var Slug2;
+((Slug) => {
+  const ADJECTIVES = [
+    "brave",
+    "calm",
+    "clever",
+    "cosmic",
+    "crisp",
+    "curious",
+    "eager",
+    "gentle",
+    "glowing",
+    "happy",
+    "hidden",
+    "jolly",
+    "kind",
+    "lucky",
+    "mighty",
+    "misty",
+    "neon",
+    "nimble",
+    "playful",
+    "proud",
+    "quick",
+    "quiet",
+    "shiny",
+    "silent",
+    "stellar",
+    "sunny",
+    "swift",
+    "tidy",
+    "witty"
+  ];
+  const NOUNS = [
+    "cabin",
+    "cactus",
+    "canyon",
+    "circuit",
+    "comet",
+    "eagle",
+    "engine",
+    "falcon",
+    "forest",
+    "garden",
+    "harbor",
+    "island",
+    "knight",
+    "lagoon",
+    "meadow",
+    "moon",
+    "mountain",
+    "nebula",
+    "orchid",
+    "otter",
+    "panda",
+    "pixel",
+    "planet",
+    "river",
+    "rocket",
+    "sailor",
+    "squid",
+    "star",
+    "tiger",
+    "wizard",
+    "wolf"
+  ];
+  function create() {
+    return [
+      ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)],
+      NOUNS[Math.floor(Math.random() * NOUNS.length)]
+    ].join("-");
+  }
+  Slug.create = create;
+})(Slug2 ||= {});
+
+export { Slug2 };

package/dist/chunks/repository-gftt206x.js

@@ -0,0 +1,6 @@
+// src/session/message.ts
+import * as SessionMessage2 from "@opencode/schema/session-message";
+
+export * from "@opencode/schema/session-message";
+
+export { SessionMessage2 };

package/dist/chunks/repository-gtm8txn9.js

@@ -0,0 +1,193 @@
+import {
+  mergeOverlay2,
+  mergeHeaders2,
+  Info31
+} from "./repository-pye8sh6e.js";
+import {
+  Info29
+} from "./repository-nxamnhdf.js";
+import {
+  Service78,
+  node83
+} from "./repository-x6rcf4cj.js";
+import {
+  create3
+} from "./repository-kg06axw8.js";
+import {
+  ID13,
+  Service74,
+  node78
+} from "./repository-0zkv00cg.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/catalog.ts
+var exports_catalog2 = {};
+__export(exports_catalog2, {
+  Catalog: () => exports_catalog2,
+  Event: () => Event17,
+  Service: () => Service73,
+  node: () => node77
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Array, Context, Effect, Layer, Order, pipe } from "effect";
+import { Catalog } from "@opencode/schema/catalog";
+import { Event as Event17 } from "@opencode/schema/catalog";
+
+class Service73 extends Context.Service()("@opencode/Catalog") {
+}
+var layer = Layer.effect(Service73, Effect.gen(function* () {
+  const bus = yield* Service78;
+  const integrations = yield* Service74;
+  const available = (provider, integration) => {
+    if (provider.activation === "disabled")
+      return false;
+    if (provider.activation === "enabled")
+      return true;
+    if (integration?.connections.length)
+      return true;
+    return provider.integrationID === undefined && !integration;
+  };
+  const projectModel = (model, provider) => {
+    return {
+      ...model,
+      ...provider.canonical === undefined ? {} : { canonical: provider.canonical },
+      package: model.package ?? provider.package,
+      compaction: model.compaction ?? provider.compaction,
+      websocket: model.websocket ?? provider.websocket,
+      settings: mergeOverlay2(provider.settings, model.settings),
+      headers: mergeHeaders2(provider.headers, model.headers),
+      body: mergeOverlay2(provider.body, model.body)
+    };
+  };
+  const state = create3({
+    name: "catalog",
+    initial: () => ({ providers: new Map }),
+    editor: (editor) => {
+      const result = {
+        provider: {
+          list: () => Array.fromIterable(editor.providers.values()),
+          get: (providerID) => editor.providers.get(providerID),
+          update: (providerID, fn) => {
+            let current = editor.providers.get(providerID);
+            if (!current) {
+              current = {
+                provider: Info31.empty(providerID),
+                models: new Map
+              };
+              editor.providers.set(providerID, current);
+            }
+            fn(current.provider);
+            current.provider.id = providerID;
+          },
+          remove: (providerID) => {
+            editor.providers.delete(providerID);
+          }
+        },
+        model: {
+          get: (providerID, modelID) => editor.providers.get(providerID)?.models.get(modelID),
+          update: (providerID, modelID, fn) => {
+            let record = editor.providers.get(providerID);
+            if (!record) {
+              record = {
+                provider: Info31.empty(providerID),
+                models: new Map
+              };
+              editor.providers.set(providerID, record);
+            }
+            const model = record.models.get(modelID) ?? Info29.default(providerID, modelID);
+            if (!record.models.has(modelID))
+              record.models.set(modelID, model);
+            fn(model);
+            model.id = modelID;
+            model.providerID = providerID;
+          },
+          remove: (providerID, modelID) => {
+            editor.providers.get(providerID)?.models.delete(modelID);
+          },
+          default: {
+            get: () => editor.defaultModel,
+            set: (providerID, modelID) => {
+              editor.defaultModel = { providerID, modelID };
+            }
+          }
+        }
+      };
+      return result;
+    },
+    notify: () => bus.publish(Catalog.Event.Updated, {}).pipe(Effect.asVoid, Effect.withSpan("Catalog.notify"))
+  });
+  const result = {
+    transform: state.transform,
+    reload: state.reload,
+    provider: {
+      get: Effect.fn("Catalog.provider.get")(function* (providerID) {
+        return state.get().providers.get(providerID)?.provider;
+      }),
+      all: Effect.fn("Catalog.provider.all")(function* () {
+        return Array.fromIterable(state.get().providers.values()).map((record) => record.provider);
+      }),
+      available: Effect.fn("Catalog.provider.available")(function* () {
+        const active = new Map((yield* integrations.list()).map((integration) => [integration.id, integration]));
+        return (yield* result.provider.all()).filter((provider) => available(provider, active.get(provider.integrationID ?? ID13.make(provider.id))));
+      })
+    },
+    model: {
+      get: Effect.fn("Catalog.model.get")(function* (providerID, modelID) {
+        const record = state.get().providers.get(providerID);
+        if (!record)
+          return;
+        const model = record.models.get(modelID);
+        return model && projectModel(model, record.provider);
+      }),
+      all: Effect.fn("Catalog.model.all")(function* () {
+        return pipe(Array.fromIterable(state.get().providers.values()), Array.flatMap((record) => {
+          return Array.fromIterable(record.models.values()).map((model) => projectModel(model, record.provider));
+        }), Array.sortWith((item) => item.time.released, Order.flip(Order.Number)));
+      }),
+      available: Effect.fn("Catalog.model.available")(function* () {
+        const providers = new Set((yield* result.provider.available()).map((provider) => provider.id));
+        const models = [];
+        for (const record of state.get().providers.values()) {
+          if (!providers.has(record.provider.id))
+            continue;
+          for (const model of record.models.values()) {
+            if (!model.enabled)
+              continue;
+            models.push(projectModel(model, record.provider));
+          }
+        }
+        return pipe(models, Array.sortWith((item) => item.time.released, Order.flip(Order.Number)));
+      }),
+      default: Effect.fn("Catalog.model.default")(function* () {
+        const defaultModel = state.get().defaultModel;
+        if (defaultModel) {
+          const provider = yield* result.provider.get(defaultModel.providerID);
+          if (provider && (yield* result.provider.available()).some((item) => item.id === provider.id)) {
+            const model = yield* result.model.get(defaultModel.providerID, defaultModel.modelID);
+            if (model?.enabled)
+              return model;
+          }
+        }
+        return (yield* result.model.available())[0];
+      }),
+      small: Effect.fn("Catalog.model.small")(function* (providerID) {
+        const record = state.get().providers.get(providerID);
+        if (!record)
+          return;
+        const models = pipe(Array.fromIterable(record.models.values()), Array.filter((model) => model.providerID === providerID && model.enabled && model.status === "active" && model.capabilities.input.some((item) => item.startsWith("text")) && model.capabilities.output.some((item) => item.startsWith("text"))), Array.sortWith((model) => model.time.released, Order.flip(Order.Number)));
+        for (const family of SMALL_MODEL_FAMILY_PRIORITY) {
+          const selected = models.find((model) => model.family === family);
+          if (selected)
+            return projectModel(selected, record.provider);
+        }
+      })
+    }
+  };
+  return Service73.of(result);
+}));
+var SMALL_MODEL_FAMILY_PRIORITY = ["gpt-luna", "gemini-flash-lite", "gemini-flash", "claude-haiku"];
+var node77 = makeLocationNode({ service: Service73, layer, deps: [node83, node78] });
+
+export { Service73, node77, exports_catalog2, Event17 };

package/dist/chunks/repository-gv6a8nnw.js

@@ -0,0 +1,25 @@
+import {
+  AbsolutePath2
+} from "./repository-922hggd3.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/worktree/directory.ts
+var exports_directory = {};
+__export(exports_directory, {
+  DirectoryUnavailableError: () => DirectoryUnavailableError2,
+  WorktreeDirectory: () => exports_directory,
+  canonical: () => canonical2
+});
+import { Effect, Schema } from "effect";
+class DirectoryUnavailableError2 extends Schema.TaggedError()("Worktree.DirectoryUnavailableError", { directory: AbsolutePath2 }) {
+}
+var canonical2 = Effect.fnUntraced(function* (fs, input) {
+  const resolved = AbsolutePath2.make(yield* fs.resolve(input));
+  if (!(yield* fs.isDir(resolved)))
+    return yield* new DirectoryUnavailableError2({ directory: input });
+  return resolved;
+});
+
+export { DirectoryUnavailableError2, canonical2, exports_directory };

package/dist/chunks/repository-gxgjkd0x.js

@@ -0,0 +1,77 @@
+import {
+  Service66
+} from "./repository-6wjjjhy6.js";
+import {
+  latest2,
+  Service44
+} from "./repository-smnv2tch.js";
+import {
+  Service14
+} from "./repository-58e8mpmb.js";
+import {
+  make7
+} from "./repository-1bbkgx8g.js";
+import {
+  observe2
+} from "./repository-qsdy395h.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/config/plugin/formatter.ts
+var exports_formatter = {};
+__export(exports_formatter, {
+  ConfigFormatterPlugin: () => exports_formatter,
+  Plugin: () => Plugin2
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+import { Npm } from "@opencode/util/npm";
+import { AppProcess } from "@opencode/util/process";
+import { Effect } from "effect";
+var Plugin2 = define({
+  id: "opencode.config.formatter",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service44;
+    const formatter = yield* Service14;
+    const fs = yield* FSUtil.Service;
+    const global = yield* Global.Service;
+    const location = yield* Service66;
+    const npm = yield* Npm.Service;
+    const processes = yield* AppProcess.Service;
+    const loaded = yield* observe2(config, ctx.event, formatter.reload());
+    yield* formatter.transform((editor) => {
+      const configured = latest2(loaded.entries, "formatter");
+      if (!configured)
+        return;
+      const builtIns = make7({
+        directory: location.directory,
+        worktree: location.project.directory,
+        fs,
+        npm,
+        processes,
+        bin: global.bin
+      });
+      builtIns.forEach(editor.set);
+      if (configured === true)
+        return;
+      for (const [name, entry] of Object.entries(configured)) {
+        if (entry.disabled) {
+          editor.remove(name);
+          continue;
+        }
+        const builtIn = builtIns.find((formatter) => formatter.name === name);
+        const current = {
+          name,
+          extensions: entry.extensions ?? builtIn?.extensions ?? [],
+          environment: { ...builtIn?.environment, ...entry.environment },
+          enabled: builtIn && !entry.command ? builtIn.enabled : Effect.succeed(entry.command ? [...entry.command] : false)
+        };
+        editor.set(current);
+      }
+    });
+  })
+});
+
+export { Plugin2, exports_formatter };