@opencode-ai/core 0.0.0-dev-19121 → 0.0.0-dev-19123

package/dist/chunks/location-services-qnnvnzf3.js

@@ -0,0 +1,287 @@
+import {
+  AbsolutePath2
+} from "./location-services-p8qxwesx.js";
+import {
+  WorktreeError2,
+  node82
+} from "./location-services-k0ya8bme.js";
+import {
+  ID17
+} from "./location-services-v60ecprk.js";
+import {
+  Slug2
+} from "./location-services-gebd4c9n.js";
+import {
+  Service80,
+  node84
+} from "./location-services-qvwjc6yp.js";
+import {
+  Service79,
+  node83
+} from "./location-services-3cwf5791.js";
+import {
+  ProjectTable2
+} from "./location-services-qvbcabdc.js";
+import {
+  WorktreeTable2
+} from "./location-services-yg7sb877.js";
+import {
+  Service76,
+  node80
+} from "./location-services-kctmjn4p.js";
+import {
+  DirectoryUnavailableError2,
+  canonical3
+} from "./location-services-y2cqme3r.js";
+import {
+  make17
+} from "./location-services-69cg10bk.js";
+import {
+  create3
+} from "./location-services-kg06axw8.js";
+import {
+  __export
+} from "./location-services-9rqn6x4v.js";
+
+// src/worktree.ts
+var exports_worktree2 = {};
+__export(exports_worktree2, {
+  CreateInput: () => CreateInput3,
+  DestinationExistsError: () => DestinationExistsError2,
+  DirectoryUnavailableError: () => DirectoryUnavailableError2,
+  Event: () => Event6,
+  Info: () => Info6,
+  InvalidDirectoryError: () => InvalidDirectoryError2,
+  List: () => List2,
+  ListEntry: () => ListEntry3,
+  OperationError: () => OperationError2,
+  RefreshResult: () => RefreshResult2,
+  RemoveInput: () => RemoveInput2,
+  Service: () => Service39,
+  SourceDirectoryNotFoundError: () => SourceDirectoryNotFoundError2,
+  StrategyID: () => StrategyID2,
+  StrategyUnavailableError: () => StrategyUnavailableError2,
+  UnsupportedLocationError: () => UnsupportedLocationError2,
+  Worktree: () => exports_worktree2,
+  node: () => node42
+});
+import { Context, Effect, Layer, Schema } from "effect";
+import { and, asc, desc, eq, isNull, sql } from "drizzle-orm";
+import path from "path";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Global } from "@opencode-ai/util/global";
+import { Worktree } from "@opencode-ai/schema/worktree";
+import { AppProcess } from "@opencode-ai/util/process";
+import { ChildProcess } from "effect/unstable/process";
+import { OperationError as OperationError2 } from "@opencode-ai/schema/worktree";
+var StrategyID2 = Worktree.StrategyID;
+var CreateInput3 = Worktree.CreateInput;
+var RemoveInput2 = Worktree.RemoveInput;
+var RefreshResult2 = Schema.Struct({
+  updated: Schema.Array(AbsolutePath2),
+  removed: Schema.Array(AbsolutePath2)
+}).annotate({ identifier: "Worktree.RefreshResult" });
+var Info6 = Worktree.Info;
+var List2 = Worktree.List;
+var ListEntry3 = Worktree.ListEntry;
+
+class SourceDirectoryNotFoundError2 extends Schema.TaggedError()("Worktree.SourceDirectoryNotFoundError", { projectID: ID17, directory: Schema.optional(AbsolutePath2) }) {
+}
+
+class DestinationExistsError2 extends Schema.TaggedError()("Worktree.DestinationExistsError", { directory: AbsolutePath2 }) {
+}
+
+class InvalidDirectoryError2 extends Schema.TaggedError()("Worktree.InvalidDirectoryError", { directory: AbsolutePath2 }) {
+}
+
+class StrategyUnavailableError2 extends Schema.TaggedError()("Worktree.StrategyUnavailableError", { strategy: StrategyID2 }) {
+}
+
+class UnsupportedLocationError2 extends Schema.TaggedError()("Worktree.UnsupportedLocationError", { directory: AbsolutePath2 }) {
+}
+var Event6 = Worktree.Event;
+
+class Service39 extends Context.Service()("@opencode/v2/Worktree") {
+}
+var layer = Layer.effect(Service39, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const database = yield* Service80;
+  const db = database.db;
+  const bus = yield* Service79;
+  const processService = yield* AppProcess.Service;
+  const location = yield* Service76;
+  const global = yield* Global.Service;
+  const projectID = location.project.id;
+  const local = location.workspaceID ? Effect.fail(new UnsupportedLocationError2({ directory: location.directory })) : Effect.void;
+  const gitStrategy = yield* make17;
+  const state = create3({
+    name: "worktree",
+    initial: () => ({
+      directory: AbsolutePath2.make(path.join(global.data, "worktree", projectID.slice(0, 6))),
+      strategies: new Map([[gitStrategy.id, gitStrategy]]),
+      selected: gitStrategy.id
+    }),
+    editor: (value) => ({
+      configure: (settings) => {
+        value.directory = settings.directory;
+      },
+      add: (strategy) => {
+        value.strategies.delete(strategy.id);
+        value.strategies.set(strategy.id, strategy);
+        value.selected = strategy.id;
+      }
+    })
+  });
+  const changed = Effect.fnUntraced(function* (update) {
+    if (update)
+      yield* bus.publish(Event6.Updated, { projectID });
+  });
+  const ops = {
+    list: Effect.fnUntraced(function* () {
+      const rows = yield* db.select({ directory: WorktreeTable2.directory, strategy: WorktreeTable2.strategy }).from(WorktreeTable2).where(eq(WorktreeTable2.project_id, projectID)).orderBy(desc(WorktreeTable2.time_created), asc(WorktreeTable2.directory)).all().pipe(Effect.orDie);
+      return rows.map((row) => ({ directory: row.directory, strategy: row.strategy ?? undefined }));
+    }),
+    find: Effect.fnUntraced(function* (directory) {
+      const row = yield* db.select({ directory: WorktreeTable2.directory, strategy: WorktreeTable2.strategy }).from(WorktreeTable2).where(and(eq(WorktreeTable2.project_id, projectID), eq(WorktreeTable2.directory, directory))).get().pipe(Effect.orDie);
+      return row ? { directory: row.directory, strategy: row.strategy ?? undefined } : undefined;
+    }),
+    create: (input, tx) => (tx ?? db).insert(WorktreeTable2).values({
+      project_id: projectID,
+      directory: input.directory,
+      strategy: input.strategy
+    }).onConflictDoUpdate({
+      target: [WorktreeTable2.project_id, WorktreeTable2.directory],
+      set: {
+        strategy: input.strategy ?? null
+      },
+      setWhere: input.replace ? undefined : input.strategy ? isNull(WorktreeTable2.strategy) : sql`false`
+    }).returning({ directory: WorktreeTable2.directory }).get().pipe(Effect.orDie, Effect.map((row) => row !== undefined)),
+    remove: (directory, tx) => (tx ?? db).delete(WorktreeTable2).where(and(eq(WorktreeTable2.project_id, projectID), eq(WorktreeTable2.directory, directory))).returning({ directory: WorktreeTable2.directory }).get().pipe(Effect.orDie, Effect.map((row) => row !== undefined))
+  };
+  const source = Effect.fnUntraced(function* (input) {
+    const sourceDirectory = input ?? location.project.directory;
+    const resolved = yield* canonical3(fs, sourceDirectory);
+    if ((yield* ops.find(resolved)) === undefined)
+      return yield* new SourceDirectoryNotFoundError2({ projectID, directory: resolved });
+    return resolved;
+  });
+  const getStrategy = Effect.fnUntraced(function* (id, strategies) {
+    const found = strategies.get(id);
+    if (!found)
+      return yield* new StrategyUnavailableError2({ strategy: id });
+    return found;
+  });
+  const create = Effect.fn("Worktree.create")(function* (input = {}) {
+    yield* local;
+    const current = state.get();
+    const selected = yield* getStrategy(input.strategy ?? current.selected, current.strategies);
+    const directory = input.directory ?? current.directory;
+    const sourceDirectory = yield* source(input.from);
+    yield* fs.makeDirectory(directory, { recursive: true }).pipe(Effect.orDie);
+    const name = input.name ?? Slug2.create();
+    let suffix = 1;
+    let worktreeDirectory = AbsolutePath2.make(path.join(directory, name));
+    while (yield* fs.existsSafe(worktreeDirectory)) {
+      suffix++;
+      if (suffix > 10)
+        return yield* new DestinationExistsError2({ directory: worktreeDirectory });
+      worktreeDirectory = AbsolutePath2.make(path.join(directory, `${name}-${suffix}`));
+    }
+    const created = yield* selected.create({
+      directory: worktreeDirectory,
+      sourceDirectory,
+      branch: input.branch
+    }).pipe(Effect.mapError((error) => operationError(selected.id, "create", error)));
+    const result = { directory: yield* canonical3(fs, created.directory) };
+    if (result.directory !== (yield* canonical3(fs, worktreeDirectory)))
+      return yield* new InvalidDirectoryError2({ directory: result.directory });
+    yield* changed(yield* ops.create({
+      directory: result.directory,
+      strategy: selected.id,
+      replace: true
+    }));
+    const project = yield* db.select({ commands: ProjectTable2.commands }).from(ProjectTable2).where(eq(ProjectTable2.id, projectID)).get().pipe(Effect.orDie);
+    const command = project?.commands?.start?.trim();
+    if (command) {
+      const windows = process.platform === "win32";
+      yield* processService.run(ChildProcess.make(windows ? command : "bash", windows ? [] : ["-lc", command], {
+        cwd: result.directory,
+        env: {
+          OPENCODE_WORKTREE_BASE: sourceDirectory,
+          OPENCODE_WORKTREE_PATH: result.directory
+        },
+        extendEnv: true,
+        stdin: "ignore",
+        shell: windows
+      })).pipe(Effect.flatMap(AppProcess.requireSuccess));
+    }
+    return result;
+  });
+  const remove = Effect.fn("Worktree.remove")(function* (input) {
+    yield* local;
+    const worktreeDirectory = yield* canonical3(fs, input.directory);
+    const stored = yield* ops.find(worktreeDirectory);
+    if (!stored?.strategy)
+      return yield* new InvalidDirectoryError2({ directory: worktreeDirectory });
+    const strategy = yield* getStrategy(StrategyID2.make(stored.strategy), state.get().strategies);
+    yield* strategy.remove({
+      directory: worktreeDirectory,
+      force: input.force
+    }).pipe(Effect.mapError((error) => operationError(strategy.id, "remove", error)));
+    yield* changed(yield* ops.remove(worktreeDirectory));
+  });
+  const refresh = Effect.fn("Worktree.refresh")(function* () {
+    yield* local;
+    const stored = yield* ops.list();
+    const checked = yield* Effect.forEach(stored, (item) => fs.isDir(item.directory).pipe(Effect.map((exists) => ({ ...item, exists }))), { concurrency: "unbounded" });
+    const strategies = Array.from(state.get().strategies.values()).toReversed();
+    const discovered = new Map;
+    if (checked.some((item) => item.directory === location.project.directory && item.exists)) {
+      for (const strategy of strategies) {
+        const entries = yield* strategy.list(location.project.directory).pipe(Effect.mapError((error) => operationError(strategy.id, "list", error)), Effect.catchTag("Worktree.DirectoryUnavailableError", () => Effect.succeed([])));
+        for (const entry of entries) {
+          const directory = yield* canonical3(fs, entry.directory).pipe(Effect.catchTag("Worktree.DirectoryUnavailableError", () => Effect.undefined));
+          if (!directory || discovered.has(directory))
+            continue;
+          discovered.set(directory, {
+            directory,
+            strategy: entry.type === "worktree" ? strategy.id : undefined
+          });
+        }
+      }
+    }
+    const removed = checked.filter((item) => !item.exists).map((item) => item.directory);
+    const changes = yield* db.transaction((tx) => Effect.all({
+      updated: Effect.filter(Array.from(discovered.values()), (item) => ops.create(item, tx)).pipe(Effect.map((items) => items.map((item) => item.directory))),
+      removed: Effect.filter(removed, (directory) => ops.remove(directory, tx))
+    })).pipe(Effect.orDie);
+    yield* changed(changes.updated.length > 0 || changes.removed.length > 0);
+    return changes;
+  });
+  return Service39.of({
+    transform: state.transform,
+    reload: state.reload,
+    list: Effect.fn("Worktree.list")(function* () {
+      yield* refresh();
+      return yield* ops.list();
+    }),
+    create,
+    remove,
+    refresh
+  });
+}));
+var node42 = makeLocationNode({
+  service: Service39,
+  layer,
+  deps: [FSUtil.node, node82, node83, node84, AppProcess.node, node80, Global.node]
+});
+function operationError(strategy, operation, error) {
+  if (error instanceof WorktreeError2 || error instanceof DirectoryUnavailableError2 || error instanceof Worktree.OperationError)
+    return error;
+  return new Worktree.OperationError({
+    message: `Worktree strategy ${strategy} failed to ${operation}: ${error instanceof globalThis.Error ? error.message : String(error)}`
+  });
+}
+
+export { StrategyID2, CreateInput3, RemoveInput2, RefreshResult2, Info6, List2, ListEntry3, SourceDirectoryNotFoundError2, DestinationExistsError2, InvalidDirectoryError2, StrategyUnavailableError2, UnsupportedLocationError2, Event6, Service39, node42, exports_worktree2, OperationError2 };

package/dist/chunks/{location-mutation-qsdy395h.js → location-services-qsdy395h.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./location-mutation-9rqn6x4v.js";
+} from "./location-services-9rqn6x4v.js";
 
 // src/config/plugin/entry-observer.ts
 var exports_entry_observer = {};

package/dist/chunks/{location-mutation-9qm9egsn.js → location-services-qvbcabdc.js}

@@ -1,10 +1,10 @@
 import {
   absoluteColumn2,
   absoluteArrayColumn2
-} from "./location-mutation-r8dhm0tv.js";
+} from "./location-services-r8dhm0tv.js";
 import {
   Timestamps2
-} from "./location-mutation-qfa1cgps.js";
+} from "./location-services-qfa1cgps.js";
 
 // src/project/sql.ts
 import { isNotNull, isNull, ne, or } from "drizzle-orm";

package/dist/chunks/{location-mutation-d3vxtdrv.js → location-services-qvwjc6yp.js}

@@ -1,12 +1,12 @@
 import {
   makeWithDefaults2
-} from "./location-mutation-4g8dp60g.js";
+} from "./location-services-ya5ydtak.js";
 import {
   apply3
-} from "./location-mutation-sy0cq7x8.js";
+} from "./location-services-8xqt1c25.js";
 import {
   __export
-} from "./location-mutation-9rqn6x4v.js";
+} from "./location-services-9rqn6x4v.js";
 
 // src/database/database.ts
 var exports_database = {};
@@ -14,9 +14,9 @@ __export(exports_database, {
   Database: () => exports_database,
   Options: () => Options11,
   Service: () => Service80,
-  configured: () => configured13,
+  configured: () => configured12,
   configuredClient: () => configuredClient2,
-  layer: () => layer26,
+  layer: () => layer25,
   layerFromClient: () => layerFromClient2,
   node: () => node84
 });
@@ -56,7 +56,7 @@ function lockFor(filename) {
   locks.set(filename, lock);
   return lock;
 }
-function layer26(options = { path: ":memory:" }) {
+function layer25(options = { path: ":memory:" }) {
   return Layer.unwrap(Effect.gen(function* () {
     const provide = (filename) => databaseLayer(filename === ":memory:" ? Semaphore.make(1) : Effect.succeed(lockFor(filename))).pipe(Layer.provide(sqliteLayer({ filename })));
     const filename = options.path ?? ":memory:";
@@ -67,8 +67,8 @@ function layer26(options = { path: ":memory:" }) {
   }));
 }
 var layerFromClient2 = databaseLayer(Semaphore.make(1));
-function configured13(options) {
-  return makeGlobalNode({ service: Service80, layer: layer26(options), deps: [Global.node] });
+function configured12(options) {
+  return makeGlobalNode({ service: Service80, layer: layer25(options), deps: [Global.node] });
 }
 function configuredClient2(client) {
   return makeGlobalNode({
@@ -77,6 +77,6 @@ function configuredClient2(client) {
     deps: [Global.node]
   });
 }
-var node84 = configured13({ path: ":memory:" });
+var node84 = configured12({ path: ":memory:" });
 
-export { Options11, Service80, layer26, layerFromClient2, configured13, configuredClient2, node84, exports_database };
+export { Options11, Service80, layer25, layerFromClient2, configured12, configuredClient2, node84, exports_database };

package/dist/chunks/{location-mutation-jph4yfm0.js → location-services-r4shs0wn.js}

@@ -1,20 +1,20 @@
 import {
   makeUnsafe2
-} from "./location-mutation-y71avatq.js";
+} from "./location-services-jwcy2c2z.js";
 import {
   Service53,
   node56
-} from "./location-mutation-wkpm2t5g.js";
+} from "./location-services-ym8n7jpx.js";
 import {
   __export
-} from "./location-mutation-9rqn6x4v.js";
+} from "./location-services-9rqn6x4v.js";
 
 // src/file-mutation.ts
 var exports_file_mutation = {};
 __export(exports_file_mutation, {
   FileMutation: () => exports_file_mutation,
-  Service: () => Service13,
-  node: () => node15,
+  Service: () => Service48,
+  node: () => node51,
   readText: () => readText2,
   syncTextBom: () => syncTextBom2
 });
@@ -22,7 +22,7 @@ import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Context, Effect, Layer } from "effect";
 import { FSUtil } from "@opencode-ai/util/fs-util";
 import { Bom } from "@opencode-ai/util/bom";
-class Service13 extends Context.Service()("@opencode/FileMutation") {
+class Service48 extends Context.Service()("@opencode/FileMutation") {
 }
 var readText2 = Effect.fn("FileMutation.readText")(function* (files, target) {
   return Bom.decodeBytes((yield* files.read(target)).bytes);
@@ -34,7 +34,7 @@ var syncTextBom2 = Effect.fn("FileMutation.syncTextBom")(function* (files, targe
   return synced.text;
 });
 var transactionLocks = makeUnsafe2();
-var layer = Layer.effect(Service13, Effect.gen(function* () {
+var layer = Layer.effect(Service48, Effect.gen(function* () {
   const environment = yield* Service53;
   const locks = makeUnsafe2();
   const withLock = (targets) => (effect) => [...new Set(targets.map(FSUtil.resolve))].sort().reduceRight((result, target) => transactionLocks.withLock(target)(result), effect);
@@ -56,8 +56,8 @@ var layer = Layer.effect(Service13, Effect.gen(function* () {
     yield* environment.files.write(input.target.absolute, new TextEncoder().encode(Bom.join(next.text, Boolean(current && Bom.has(current)) || next.bom)));
     return writeResult(input.target, current !== undefined);
   })));
-  return Service13.of({ withLock, write, writeTextPreservingBom });
+  return Service48.of({ withLock, write, writeTextPreservingBom });
 }));
-var node15 = makeLocationNode({ service: Service13, layer, deps: [node56] });
+var node51 = makeLocationNode({ service: Service48, layer, deps: [node56] });
 
-export { Service13, readText2, syncTextBom2, node15, exports_file_mutation };
+export { Service48, readText2, syncTextBom2, node51, exports_file_mutation };

package/dist/chunks/{location-mutation-r8dhm0tv.js → location-services-r8dhm0tv.js}

@@ -1,6 +1,6 @@
 import {
   AbsolutePath2
-} from "./location-mutation-p8qxwesx.js";
+} from "./location-services-p8qxwesx.js";
 
 // src/database/path.ts
 import nodePath from "path";

package/dist/chunks/{location-mutation-geemq6eh.js → location-services-rj5w3mtz.js}

@@ -2,20 +2,20 @@ import {
   AgentNotFoundError2,
   StepFailedError2,
   UserInterruptedError2
-} from "./location-mutation-gfgqbam0.js";
+} from "./location-services-c28brx2k.js";
 import {
   BlockedError2
-} from "./location-mutation-msb8yzxf.js";
+} from "./location-services-30r17csp.js";
 import {
   AuthorizationError2
-} from "./location-mutation-h0rsqts8.js";
+} from "./location-services-bexxahbt.js";
 import {
   ModelNotSelectedError2,
   ModelUnavailableError2,
   VariantUnavailableError2,
   UnsupportedPackageError2,
   UnresolvedProviderVariablesError2
-} from "./location-mutation-crrrqmng.js";
+} from "./location-services-kpgzv4p9.js";
 
 // src/session/to-session-error.ts
 import { AIError, ToolFailure } from "@opencode-ai/ai";

package/dist/chunks/{location-mutation-wfsrt4xp.js → location-services-rjgrhwwz.js}

@@ -1,15 +1,15 @@
 import {
   ps2
-} from "./location-mutation-h0z9htzn.js";
+} from "./location-services-9mwtsm6t.js";
 import {
   lazy2
-} from "./location-mutation-88xbtdfr.js";
+} from "./location-services-88xbtdfr.js";
 import {
   match2
-} from "./location-mutation-y1fvbwt7.js";
+} from "./location-services-y1fvbwt7.js";
 import {
   __export
-} from "./location-mutation-9rqn6x4v.js";
+} from "./location-services-9rqn6x4v.js";
 
 // src/shell/parse.ts
 var exports_parse = {};

package/dist/chunks/{location-mutation-aj7d9r5a.js → location-services-rmy3e5eg.js}

@@ -1,8 +1,8 @@
 import {
-  ID16,
+  ID18,
   isAISDK2,
   packageName2
-} from "./location-mutation-rvb2zp0m.js";
+} from "./location-services-4z6b0fg6.js";
 
 // src/plugin/provider/amazon-bedrock.ts
 import { Effect } from "effect";
@@ -88,7 +88,7 @@ var AmazonBedrockPlugin2 = define({
       evt.sdk = mod.createAmazonBedrock(options);
     }));
     yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
-      if (evt.model.providerID !== ID16.amazonBedrock)
+      if (evt.model.providerID !== ID18.amazonBedrock)
         return;
       if (isAISDK2(evt.model.package) && packageName2(evt.model.package) === "@ai-sdk/amazon-bedrock/mantle") {
         evt.language = selectMantleModel(evt.sdk, evt.model.modelID ?? evt.model.id);

package/dist/chunks/{location-mutation-kx2gvdct.js → location-services-rvhss2m2.js}

@@ -1,17 +1,17 @@
 import {
   __export
-} from "./location-mutation-9rqn6x4v.js";
+} from "./location-services-9rqn6x4v.js";
 
 // src/plugin/mcp-codemode-exclusion.ts
 var exports_mcp_codemode_exclusion = {};
 __export(exports_mcp_codemode_exclusion, {
   McpCodeModeExclusionPlugin: () => exports_mcp_codemode_exclusion,
-  Plugin: () => Plugin12
+  Plugin: () => Plugin38
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect } from "effect";
 var urls = [/^https:\/\/executor\.sh\/[^/]+\/mcp$/];
-var Plugin12 = define({
+var Plugin38 = define({
   id: "opencode.mcp.codemode.exclusion",
   effect: Effect.fn(function* (ctx) {
     yield* ctx.mcp.transform((editor) => {
@@ -34,4 +34,4 @@ var Plugin12 = define({
   })
 });
 
-export { Plugin12, exports_mcp_codemode_exclusion };
+export { Plugin38, exports_mcp_codemode_exclusion };

package/dist/chunks/{location-mutation-6tkeq6mm.js → location-services-rxzgqjy1.js}

@@ -1,12 +1,12 @@
 import {
   AbsolutePath2
-} from "./location-mutation-p8qxwesx.js";
+} from "./location-services-p8qxwesx.js";
 import {
   Service76
-} from "./location-mutation-ext0y26q.js";
+} from "./location-services-kctmjn4p.js";
 import {
   __export
-} from "./location-mutation-9rqn6x4v.js";
+} from "./location-services-9rqn6x4v.js";
 
 // src/config/discovery.ts
 var exports_discovery2 = {};

package/dist/chunks/{location-mutation-8jxcp26p.js → location-services-s18jmqte.js}

@@ -1,22 +1,22 @@
 import {
   Service79
-} from "./location-mutation-ddbs5teb.js";
+} from "./location-services-3cwf5791.js";
 import {
   Service76
-} from "./location-mutation-ext0y26q.js";
+} from "./location-services-kctmjn4p.js";
 import {
   PromptsChanged2,
-  Service37
-} from "./location-mutation-xc28r99p.js";
+  Service34
+} from "./location-services-m372t30b.js";
 import {
   __export
-} from "./location-mutation-9rqn6x4v.js";
+} from "./location-services-9rqn6x4v.js";
 
 // src/plugin/command.ts
-var exports_command = {};
-__export(exports_command, {
-  CommandPlugin: () => exports_command,
-  Plugin: () => Plugin13
+var exports_command2 = {};
+__export(exports_command2, {
+  CommandPlugin: () => exports_command2,
+  Plugin: () => Plugin42
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect, Stream } from "effect";
@@ -193,11 +193,11 @@ If you're uncertain about something and can't verify it with these tools, say "I
 `;
 
 // src/plugin/command.ts
-var Plugin13 = define({
+var Plugin42 = define({
   id: "opencode.command",
   effect: Effect.fn(function* (ctx) {
     const location = yield* Service76;
-    const mcp = yield* Service37;
+    const mcp = yield* Service34;
     const bus = yield* Service79;
     const loaded = { prompts: [] };
     yield* bus.subscribe(PromptsChanged2).pipe(Stream.runForEach(() => mcp.prompts().pipe(Effect.tap((prompts) => Effect.sync(() => loaded.prompts = prompts)), Effect.andThen(ctx.command.reload()))), Effect.forkScoped({ startImmediately: true }));
@@ -280,4 +280,4 @@ function sanitize(value) {
 var argsRegex = /(?:\[Image\s+\d+\]|"[^"]*"|'[^']*'|[^\s"']+)/gi;
 var quoteTrimRegex = /^["']|["']$/g;
 
-export { Plugin13, exports_command };
+export { Plugin42, exports_command2 };