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

package/dist/chunks/location-mutation-m1v38ztw.js

@@ -1,22 +0,0 @@
-import {
-  Plugin5
-} from "./location-mutation-8z5rgnjd.js";
-import {
-  Plugin7
-} from "./location-mutation-ms7jfr1m.js";
-import {
-  Plugin6
-} from "./location-mutation-prk0e8fy.js";
-import {
-  Plugin8
-} from "./location-mutation-bjjsq4aq.js";
-
-// src/plugin/websearch/index.ts
-var WebSearchPlugins2 = [
-  Plugin5,
-  Plugin7,
-  Plugin6,
-  Plugin8
-];
-
-export { WebSearchPlugins2 };

package/dist/chunks/location-mutation-xrrv7eja.js

@@ -1,269 +0,0 @@
-import {
-  AbsolutePath2
-} from "./location-mutation-p8qxwesx.js";
-import {
-  node82
-} from "./location-mutation-7xfsdta4.js";
-import {
-  ID18
-} from "./location-mutation-tppvcy65.js";
-import {
-  Slug2
-} from "./location-mutation-gebd4c9n.js";
-import {
-  Service80,
-  node84
-} from "./location-mutation-d3vxtdrv.js";
-import {
-  Service79,
-  node83
-} from "./location-mutation-ddbs5teb.js";
-import {
-  ProjectTable2
-} from "./location-mutation-9qm9egsn.js";
-import {
-  WorktreeTable2
-} from "./location-mutation-ajtjthsy.js";
-import {
-  Service76,
-  node80
-} from "./location-mutation-ext0y26q.js";
-import {
-  DirectoryUnavailableError2,
-  canonical2
-} from "./location-mutation-93a8yfjt.js";
-import {
-  make10
-} from "./location-mutation-j11ebv35.js";
-import {
-  __export
-} from "./location-mutation-9rqn6x4v.js";
-
-// src/worktree.ts
-var exports_worktree = {};
-__export(exports_worktree, {
-  CreateInput: () => CreateInput2,
-  DestinationExistsError: () => DestinationExistsError2,
-  DirectoryUnavailableError: () => DirectoryUnavailableError2,
-  DuplicateStrategyError: () => DuplicateStrategyError2,
-  Event: () => Event2,
-  Info: () => Info2,
-  InvalidDirectoryError: () => InvalidDirectoryError2,
-  List: () => List2,
-  ListEntry: () => ListEntry3,
-  ListInput: () => ListInput2,
-  RefreshInput: () => RefreshInput2,
-  RefreshResult: () => RefreshResult2,
-  RemoveInput: () => RemoveInput2,
-  Service: () => Service14,
-  SourceDirectoryNotFoundError: () => SourceDirectoryNotFoundError2,
-  StrategyID: () => StrategyID2,
-  StrategyUnavailableError: () => StrategyUnavailableError2,
-  Worktree: () => exports_worktree,
-  node: () => node16,
-  refreshAfterBoot: () => refreshAfterBoot2,
-  refreshNode: () => refreshNode2
-});
-import { Context, Effect, Layer, Schema } from "effect";
-import { and, asc, desc, eq, isNotNull, isNull, ne, or } from "drizzle-orm";
-import path from "path";
-import { FSUtil } from "@opencode-ai/util/fs-util";
-import { Global } from "@opencode-ai/util/global";
-import { makeGlobalNode, makeLocationNode } from "@opencode-ai/util/effect/app-node";
-import { Worktree } from "@opencode-ai/schema/worktree";
-import { AppProcess } from "@opencode-ai/util/process";
-import { ChildProcess } from "effect/unstable/process";
-var StrategyID2 = Worktree.StrategyID;
-var CreateInput2 = Worktree.CreateInput;
-var RemoveInput2 = Worktree.RemoveInput;
-var RefreshInput2 = Schema.Struct({
-  projectID: ID18
-}).annotate({ identifier: "Worktree.RefreshInput" });
-var RefreshResult2 = Schema.Struct({
-  updated: Schema.Array(AbsolutePath2),
-  removed: Schema.Array(AbsolutePath2)
-}).annotate({ identifier: "Worktree.RefreshResult" });
-var Info2 = Worktree.Info;
-var ListInput2 = Worktree.ListInput;
-var List2 = Worktree.List;
-var ListEntry3 = Schema.Struct({
-  directory: AbsolutePath2,
-  type: Schema.Literals(["root", "worktree"])
-}).annotate({ identifier: "Worktree.ListEntry" });
-
-class SourceDirectoryNotFoundError2 extends Schema.TaggedError()("Worktree.SourceDirectoryNotFoundError", { projectID: ID18, 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 DuplicateStrategyError2 extends Schema.TaggedError()("Worktree.DuplicateStrategyError", { strategy: StrategyID2 }) {
-}
-var Event2 = Worktree.Event;
-
-class Service14 extends Context.Service()("@opencode/v2/Worktree") {
-}
-var refreshAfterBoot2 = Effect.gen(function* () {
-  const location = yield* Service76;
-  const worktrees = yield* Service14;
-  yield* Effect.gen(function* () {
-    yield* Effect.logInfo("worktree refresh started", { projectID: location.project.id });
-    const result = yield* worktrees.refresh({ projectID: location.project.id });
-    yield* Effect.logInfo("worktree refresh done", {
-      projectID: location.project.id,
-      updated: result.updated,
-      removed: result.removed
-    });
-  }).pipe(Effect.catchCause((cause) => Effect.logWarning("worktree refresh failed", { cause })), Effect.forkScoped, Effect.asVoid);
-});
-var layer = Layer.effect(Service14, Effect.gen(function* () {
-  const fs = yield* FSUtil.Service;
-  const global = yield* Global.Service;
-  const db = (yield* Service80).db;
-  const bus = yield* Service79;
-  const processService = yield* AppProcess.Service;
-  const changed = Effect.fnUntraced(function* (projectID, update) {
-    if (update)
-      yield* bus.publish(Event2.Updated, { projectID });
-  });
-  const ops = {
-    list: Effect.fn("Worktree.list")(function* (projectID) {
-      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* (projectID, 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;
-    }),
-    primary: Effect.fnUntraced(function* (projectID) {
-      return yield* db.select({ directory: ProjectTable2.worktree }).from(ProjectTable2).where(eq(ProjectTable2.id, projectID)).get().pipe(Effect.orDie);
-    }),
-    create: (input, tx) => (tx ?? db).insert(WorktreeTable2).values({ project_id: input.projectID, directory: input.directory, strategy: input.strategy }).onConflictDoUpdate({
-      target: [WorktreeTable2.project_id, WorktreeTable2.directory],
-      set: { strategy: input.strategy ?? null },
-      setWhere: input.strategy ? or(isNull(WorktreeTable2.strategy), ne(WorktreeTable2.strategy, input.strategy)) : isNotNull(WorktreeTable2.strategy)
-    }).returning({ directory: WorktreeTable2.directory }).get().pipe(Effect.orDie, Effect.map((row) => row !== undefined)),
-    remove: (projectID, 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 registry = new Map;
-  const register = Effect.fn("Worktree.register")(function* (strategy) {
-    if (registry.has(strategy.id))
-      return yield* new DuplicateStrategyError2({ strategy: strategy.id });
-    registry.set(strategy.id, strategy);
-  });
-  const gitStrategy = yield* make10;
-  yield* register(gitStrategy).pipe(Effect.orDie);
-  const source = Effect.fnUntraced(function* (input, projectID) {
-    const sourceDirectory = input ?? (yield* ops.primary(projectID))?.directory;
-    if (!sourceDirectory)
-      return yield* new SourceDirectoryNotFoundError2({ projectID });
-    const resolved = yield* canonical2(fs, sourceDirectory);
-    if ((yield* ops.find(projectID, resolved)) === undefined)
-      return yield* new SourceDirectoryNotFoundError2({ projectID, directory: resolved });
-    return resolved;
-  });
-  const getStrategy = Effect.fnUntraced(function* (id) {
-    const found = registry.get(id);
-    if (!found)
-      return yield* new StrategyUnavailableError2({ strategy: id });
-    return found;
-  });
-  const create = Effect.fn("Worktree.create")(function* (input) {
-    const selected = yield* getStrategy(input.strategy);
-    const sourceDirectory = yield* source(input.from, input.projectID);
-    const directory = input.directory ?? path.join(global.data, "worktree", input.projectID.slice(0, 6));
-    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 result = yield* selected.create({
-      directory: worktreeDirectory,
-      sourceDirectory,
-      branch: input.branch
-    });
-    yield* changed(input.projectID, yield* ops.create({
-      projectID: input.projectID,
-      directory: result.directory,
-      strategy: input.strategy
-    }));
-    const project = yield* db.select({ commands: ProjectTable2.commands }).from(ProjectTable2).where(eq(ProjectTable2.id, input.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) {
-    const worktreeDirectory = yield* canonical2(fs, input.directory);
-    const stored = yield* ops.find(input.projectID, worktreeDirectory);
-    if (!stored?.strategy)
-      return yield* new InvalidDirectoryError2({ directory: worktreeDirectory });
-    const strategy = yield* getStrategy(StrategyID2.make(stored.strategy));
-    yield* strategy.remove({
-      directory: worktreeDirectory,
-      force: input.force
-    });
-    yield* changed(input.projectID, yield* ops.remove(input.projectID, worktreeDirectory));
-  });
-  const refresh = Effect.fn("Worktree.refresh")(function* (input) {
-    const stored = yield* ops.list(input.projectID);
-    const checked = yield* Effect.forEach(stored, (item) => fs.isDir(item.directory).pipe(Effect.map((exists) => ({ ...item, exists }))), { concurrency: "unbounded" });
-    const sourceDirectories = checked.filter((item) => item.strategy === undefined && item.exists).map((item) => item.directory);
-    const discovered = yield* Effect.forEach(sourceDirectories, (sourceDirectory) => Effect.forEach(Array.from(registry.values()), (strategy) => strategy.list(sourceDirectory).pipe(Effect.catchTag("Worktree.DirectoryUnavailableError", () => Effect.succeed([])), Effect.map((items) => items.map((item) => ({
-      directory: item.directory,
-      strategy: item.type === "worktree" ? strategy.id : undefined
-    }))))), { concurrency: "unbounded" }).pipe(Effect.map((sets) => new Map(sets.flat(2).map((item) => [item.directory, item])).values().toArray()));
-    const removed = checked.filter((item) => !item.exists).map((item) => item.directory);
-    const changes = yield* db.transaction((tx) => Effect.all({
-      updated: Effect.filter(discovered, (item) => ops.create({
-        projectID: input.projectID,
-        directory: item.directory,
-        strategy: item.strategy
-      }, tx)).pipe(Effect.map((items) => items.map((item) => item.directory))),
-      removed: Effect.filter(removed, (directory) => ops.remove(input.projectID, directory, tx))
-    })).pipe(Effect.orDie);
-    yield* changed(input.projectID, changes.updated.length > 0 || changes.removed.length > 0);
-    return changes;
-  });
-  return Service14.of({
-    register,
-    list: ops.list,
-    create,
-    remove,
-    refresh
-  });
-}));
-var node16 = makeGlobalNode({
-  service: Service14,
-  layer,
-  deps: [FSUtil.node, Global.node, node82, node83, node84, AppProcess.node]
-});
-var refreshNode2 = makeLocationNode({
-  name: "worktree-refresh",
-  layer: Layer.effectDiscard(refreshAfterBoot2),
-  deps: [node16, node80]
-});
-
-export { StrategyID2, CreateInput2, RemoveInput2, RefreshInput2, RefreshResult2, Info2, ListInput2, List2, ListEntry3, SourceDirectoryNotFoundError2, DestinationExistsError2, InvalidDirectoryError2, StrategyUnavailableError2, DuplicateStrategyError2, Event2, Service14, refreshAfterBoot2, node16, refreshNode2, exports_worktree };