@opencode/plugin 0.0.0-reserved → 2.0.0

package/dist/promise/websearch.d.ts

@@ -0,0 +1,21 @@
+import type { WebSearch } from "@opencode/schema/websearch";
+import type { WebSearchApi } from "@opencode/client/promise/api";
+import type { Transform } from "./registration.js";
+export interface WebSearchDefinition {
+    readonly id: string;
+    readonly name: string;
+    readonly execute: (input: WebSearch.ProviderInput, context: {
+        readonly signal: AbortSignal;
+    }) => Promise<readonly WebSearch.Result[]>;
+}
+export interface WebSearchDomain extends WebSearchApi {
+    readonly transform: Transform<WebSearchEditor>;
+    readonly reload: () => Promise<void>;
+}
+export interface WebSearchEditor {
+    add(definition: WebSearchDefinition): void;
+    readonly default: {
+        get(): string | false | undefined;
+        set(selection: string | false): void;
+    };
+}

package/dist/promise/worktree.d.ts

@@ -0,0 +1,23 @@
+import type { WorktreeApi } from "@opencode/client/promise/api";
+import type { WorktreeCreateInput, WorktreeEntry, WorktreeRemoveInput, WorktreeResult } from "../worktree.js";
+import type { Transform } from "./registration.js";
+export interface WorktreeDefinition {
+    readonly id: string;
+    readonly create: (input: WorktreeCreateInput, context: {
+        readonly signal: AbortSignal;
+    }) => Promise<WorktreeResult>;
+    readonly remove: (input: WorktreeRemoveInput, context: {
+        readonly signal: AbortSignal;
+    }) => Promise<void>;
+    readonly list: (sourceDirectory: string, context: {
+        readonly signal: AbortSignal;
+    }) => Promise<readonly WorktreeEntry[]>;
+}
+export interface WorktreeEditor {
+    /** Registers an implementation and selects it as the default. Later active registrations win. */
+    add(definition: WorktreeDefinition): void;
+}
+export interface WorktreeDomain extends WorktreeApi {
+    readonly transform: Transform<WorktreeEditor>;
+    readonly reload: () => Promise<void>;
+}

package/dist/rpc.d.ts

@@ -0,0 +1 @@
+export { Rpc } from "@opencode/schema/rpc";

package/dist/rpc.js

@@ -0,0 +1 @@
+export { Rpc } from "@opencode/schema/rpc";

package/dist/source.bun.d.ts

@@ -0,0 +1,4 @@
+export declare function prepareSource(entrypoint: string, track: (file: string, directory?: boolean) => void): Promise<{
+    version: string;
+    load: () => Promise<unknown>;
+}>;

package/dist/source.bun.js

@@ -0,0 +1,62 @@
+import { createRequire } from "node:module";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { Host } from "./host.js";
+import { localSource } from "./source.js";
+let generation = Date.now();
+export async function prepareSource(entrypoint, track) {
+    const root = fileURLToPath(entrypoint);
+    const files = new Set();
+    const visit = (file, search = "") => {
+        if (file !== root && file.split(path.sep).includes("node_modules"))
+            return;
+        if (search)
+            delete require.cache[file + search];
+        if (files.has(file))
+            return;
+        files.add(file);
+        // Bun exposes ESM here too. Delete known keys even when absent: rejected
+        // evaluations are not enumerable, but deletion still invalidates them.
+        delete require.cache[file];
+        track(file);
+        if (!/\.[cm]?[jt]sx?$/.test(file))
+            return;
+        // Scan dependencies only; the normal runtime loader still owns compilation,
+        // package resolution, import attributes, and error reporting.
+        const imports = (() => {
+            try {
+                return new Bun.Transpiler({
+                    loader: file.endsWith("tsx") ? "tsx" : file.endsWith("jsx") ? "jsx" : /\.[cm]?ts$/.test(file) ? "ts" : "js",
+                    target: "bun",
+                }).scan(readFileSync(file, "utf8")).imports;
+            }
+            catch {
+                return [];
+            }
+        })();
+        for (const item of imports) {
+            const local = item.path.startsWith("./") || item.path.startsWith("../")
+                ? new URL(item.path, pathToFileURL(file))
+                : localSource(item.path, path.dirname(file));
+            if (!local)
+                continue;
+            const requested = fileURLToPath(local);
+            // Resolving a workspace symlink can erase its node_modules boundary.
+            if (requested.split(path.sep).includes("node_modules"))
+                continue;
+            try {
+                visit(item.kind === "require-call"
+                    ? createRequire(file).resolve(requested)
+                    : Bun.resolveSync(requested, path.dirname(file)), local.search);
+            }
+            catch {
+                // A missing local dependency may appear on the next save. Leave its
+                // actual failure (or optional fallback) to the native loader.
+                track(path.dirname(requested), true);
+            }
+        }
+    };
+    visit(root);
+    return { version: String(++generation), load: () => Host.load(entrypoint) };
+}

package/dist/source.d.ts

@@ -0,0 +1,8 @@
+export declare function createPluginSources(watch: (file: string) => Promise<void>): {
+    read: (entrypoint: string) => Promise<{
+        version: string;
+        module: unknown;
+    }>;
+    dispose: () => void;
+};
+export declare function localSource(spec: string, directory: string): import("url").URL | undefined;

package/dist/source.js

@@ -0,0 +1,59 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import path from "node:path";
+import { Hash } from "@opencode/util/hash";
+// Keep source fingerprints and import attempts together. Filesystem events
+// should reload changed local graphs, not repeat unchanged evaluations.
+export function createPluginSources(watch) {
+    const sources = new Map();
+    const cleanups = [];
+    const watching = new Set();
+    return {
+        read: async (entrypoint) => {
+            await Promise.all(watching);
+            const previous = sources.get(entrypoint);
+            if (previous && [...previous.files].every(([file, item]) => item.digest === digest(file, item.directory)))
+                return previous.loaded;
+            const files = new Map();
+            const track = (file, directory = false) => {
+                if (files.has(file))
+                    return;
+                files.set(file, { digest: digest(file, directory), directory });
+                const pending = watch(file).finally(() => watching.delete(pending));
+                watching.add(pending);
+                // Watch setup can be interrupted while module evaluation is still pending.
+                void pending.catch(() => { });
+            };
+            track(fileURLToPath(entrypoint));
+            const { prepareSource } = await import("#plugin-source");
+            const prepared = await prepareSource(entrypoint, track);
+            if (prepared.dispose)
+                cleanups.push(prepared.dispose);
+            // Cache the attempt before evaluating it: unchanged failing modules must
+            // not repeat import-time effects on every filesystem notification.
+            const loaded = prepared.load().then((module) => ({ version: prepared.version, module }));
+            sources.set(entrypoint, { loaded, files });
+            return loaded.finally(() => Promise.all(watching));
+        },
+        dispose: () => {
+            for (const cleanup of cleanups.splice(0))
+                cleanup();
+            sources.clear();
+        },
+    };
+}
+function digest(file, directory) {
+    try {
+        return Hash.sha256(directory ? JSON.stringify(readdirSync(file).sort()) : readFileSync(file));
+    }
+    catch {
+        return "missing";
+    }
+}
+export function localSource(spec, directory) {
+    if (spec.startsWith("file://"))
+        return new URL(spec);
+    if (spec.startsWith("./") || spec.startsWith("../") || path.isAbsolute(spec))
+        return pathToFileURL(path.resolve(directory, spec));
+    return undefined;
+}

package/dist/source.node.d.ts

@@ -0,0 +1,5 @@
+export declare function prepareSource(entrypoint: string, track: (file: string, directory?: boolean) => void): Promise<{
+    version: string;
+    load: () => Promise<unknown>;
+    dispose: () => void;
+}>;

package/dist/source.node.js

@@ -0,0 +1,45 @@
+import { registerHooks } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { localSource } from "./source.js";
+import { Host } from "./host.js";
+let generation = Date.now();
+export async function prepareSource(entrypoint, track) {
+    const version = String(++generation);
+    const fresh = (specifier) => {
+        const url = new URL(specifier);
+        url.searchParams.set("__opencode_reload", version);
+        return url.href;
+    };
+    const hook = registerHooks({
+        resolve(specifier, context, nextResolve) {
+            if (!context.parentURL || new URL(context.parentURL).searchParams.get("__opencode_reload") !== version)
+                return nextResolve(specifier, context);
+            const local = specifier.startsWith("./") || specifier.startsWith("../")
+                ? new URL(specifier, context.parentURL)
+                : localSource(specifier, path.dirname(fileURLToPath(context.parentURL)));
+            if (!local)
+                return nextResolve(specifier, context);
+            if (fileURLToPath(local).split(path.sep).includes("node_modules"))
+                return nextResolve(specifier, context);
+            const resolved = (() => {
+                try {
+                    return nextResolve(specifier, context);
+                }
+                catch (error) {
+                    track(path.dirname(fileURLToPath(local)), true);
+                    throw error;
+                }
+            })();
+            if (!resolved.url.startsWith("file:"))
+                return resolved;
+            const file = fileURLToPath(resolved.url);
+            if (file.split(path.sep).includes("node_modules"))
+                return resolved;
+            track(file);
+            return { ...resolved, url: fresh(resolved.url) };
+        },
+    });
+    const specifier = fresh(entrypoint);
+    return { version: specifier, load: () => Host.load(specifier), dispose: () => hook.deregister() };
+}

package/dist/storage.d.ts

@@ -0,0 +1,14 @@
+import type { Schema } from "effect";
+export interface StorageEntry {
+    readonly key: string;
+    readonly value: Schema.Json;
+}
+export interface StorageScanOptions {
+    readonly prefix: string;
+    readonly after?: string;
+    readonly limit?: number;
+}
+export interface StorageScanResult {
+    readonly entries: readonly StorageEntry[];
+    readonly next?: string;
+}