agentf 0.6.0 → 0.8.0

data/.opencode/node_modules/@opencode-ai/plugin/dist/index.d.ts

@@ -0,0 +1,232 @@
+import type { Event, createOpencodeClient, Project, Model, Provider, Permission, UserMessage, Message, Part, Auth, Config } from "@opencode-ai/sdk";
+import type { BunShell } from "./shell";
+import { type ToolDefinition } from "./tool";
+export * from "./tool";
+export type ProviderContext = {
+    source: "env" | "config" | "custom" | "api";
+    info: Provider;
+    options: Record<string, any>;
+};
+export type PluginInput = {
+    client: ReturnType<typeof createOpencodeClient>;
+    project: Project;
+    directory: string;
+    worktree: string;
+    serverUrl: URL;
+    $: BunShell;
+};
+export type Plugin = (input: PluginInput) => Promise<Hooks>;
+export type AuthHook = {
+    provider: string;
+    loader?: (auth: () => Promise<Auth>, provider: Provider) => Promise<Record<string, any>>;
+    methods: ({
+        type: "oauth";
+        label: string;
+        prompts?: Array<{
+            type: "text";
+            key: string;
+            message: string;
+            placeholder?: string;
+            validate?: (value: string) => string | undefined;
+            condition?: (inputs: Record<string, string>) => boolean;
+        } | {
+            type: "select";
+            key: string;
+            message: string;
+            options: Array<{
+                label: string;
+                value: string;
+                hint?: string;
+            }>;
+            condition?: (inputs: Record<string, string>) => boolean;
+        }>;
+        authorize(inputs?: Record<string, string>): Promise<AuthOuathResult>;
+    } | {
+        type: "api";
+        label: string;
+        prompts?: Array<{
+            type: "text";
+            key: string;
+            message: string;
+            placeholder?: string;
+            validate?: (value: string) => string | undefined;
+            condition?: (inputs: Record<string, string>) => boolean;
+        } | {
+            type: "select";
+            key: string;
+            message: string;
+            options: Array<{
+                label: string;
+                value: string;
+                hint?: string;
+            }>;
+            condition?: (inputs: Record<string, string>) => boolean;
+        }>;
+        authorize?(inputs?: Record<string, string>): Promise<{
+            type: "success";
+            key: string;
+            provider?: string;
+        } | {
+            type: "failed";
+        }>;
+    })[];
+};
+export type AuthOuathResult = {
+    url: string;
+    instructions: string;
+} & ({
+    method: "auto";
+    callback(): Promise<({
+        type: "success";
+        provider?: string;
+    } & ({
+        refresh: string;
+        access: string;
+        expires: number;
+        accountId?: string;
+    } | {
+        key: string;
+    })) | {
+        type: "failed";
+    }>;
+} | {
+    method: "code";
+    callback(code: string): Promise<({
+        type: "success";
+        provider?: string;
+    } & ({
+        refresh: string;
+        access: string;
+        expires: number;
+        accountId?: string;
+    } | {
+        key: string;
+    })) | {
+        type: "failed";
+    }>;
+});
+export interface Hooks {
+    event?: (input: {
+        event: Event;
+    }) => Promise<void>;
+    config?: (input: Config) => Promise<void>;
+    tool?: {
+        [key: string]: ToolDefinition;
+    };
+    auth?: AuthHook;
+    /**
+     * Called when a new message is received
+     */
+    "chat.message"?: (input: {
+        sessionID: string;
+        agent?: string;
+        model?: {
+            providerID: string;
+            modelID: string;
+        };
+        messageID?: string;
+        variant?: string;
+    }, output: {
+        message: UserMessage;
+        parts: Part[];
+    }) => Promise<void>;
+    /**
+     * Modify parameters sent to LLM
+     */
+    "chat.params"?: (input: {
+        sessionID: string;
+        agent: string;
+        model: Model;
+        provider: ProviderContext;
+        message: UserMessage;
+    }, output: {
+        temperature: number;
+        topP: number;
+        topK: number;
+        options: Record<string, any>;
+    }) => Promise<void>;
+    "chat.headers"?: (input: {
+        sessionID: string;
+        agent: string;
+        model: Model;
+        provider: ProviderContext;
+        message: UserMessage;
+    }, output: {
+        headers: Record<string, string>;
+    }) => Promise<void>;
+    "permission.ask"?: (input: Permission, output: {
+        status: "ask" | "deny" | "allow";
+    }) => Promise<void>;
+    "command.execute.before"?: (input: {
+        command: string;
+        sessionID: string;
+        arguments: string;
+    }, output: {
+        parts: Part[];
+    }) => Promise<void>;
+    "tool.execute.before"?: (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        args: any;
+    }) => Promise<void>;
+    "shell.env"?: (input: {
+        cwd: string;
+        sessionID?: string;
+        callID?: string;
+    }, output: {
+        env: Record<string, string>;
+    }) => Promise<void>;
+    "tool.execute.after"?: (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+        args: any;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: any;
+    }) => Promise<void>;
+    "experimental.chat.messages.transform"?: (input: {}, output: {
+        messages: {
+            info: Message;
+            parts: Part[];
+        }[];
+    }) => Promise<void>;
+    "experimental.chat.system.transform"?: (input: {
+        sessionID?: string;
+        model: Model;
+    }, output: {
+        system: string[];
+    }) => Promise<void>;
+    /**
+     * Called before session compaction starts. Allows plugins to customize
+     * the compaction prompt.
+     *
+     * - `context`: Additional context strings appended to the default prompt
+     * - `prompt`: If set, replaces the default compaction prompt entirely
+     */
+    "experimental.session.compacting"?: (input: {
+        sessionID: string;
+    }, output: {
+        context: string[];
+        prompt?: string;
+    }) => Promise<void>;
+    "experimental.text.complete"?: (input: {
+        sessionID: string;
+        messageID: string;
+        partID: string;
+    }, output: {
+        text: string;
+    }) => Promise<void>;
+    /**
+     * Modify tool definitions (description and parameters) sent to LLM
+     */
+    "tool.definition"?: (input: {
+        toolID: string;
+    }, output: {
+        description: string;
+        parameters: any;
+    }) => Promise<void>;
+}

data/.opencode/node_modules/@opencode-ai/plugin/dist/index.js

@@ -0,0 +1 @@
+export * from "./tool";

data/.opencode/node_modules/@opencode-ai/plugin/dist/shell.d.ts

@@ -0,0 +1,109 @@
+export type ShellFunction = (input: Uint8Array) => Uint8Array;
+export type ShellExpression = {
+    toString(): string;
+} | Array<ShellExpression> | string | {
+    raw: string;
+} | ReadableStream;
+export interface BunShell {
+    (strings: TemplateStringsArray, ...expressions: ShellExpression[]): BunShellPromise;
+    /**
+     * Perform bash-like brace expansion on the given pattern.
+     * @param pattern - Brace pattern to expand
+     */
+    braces(pattern: string): string[];
+    /**
+     * Escape strings for input into shell commands.
+     */
+    escape(input: string): string;
+    /**
+     * Change the default environment variables for shells created by this instance.
+     */
+    env(newEnv?: Record<string, string | undefined>): BunShell;
+    /**
+     * Default working directory to use for shells created by this instance.
+     */
+    cwd(newCwd?: string): BunShell;
+    /**
+     * Configure the shell to not throw an exception on non-zero exit codes.
+     */
+    nothrow(): BunShell;
+    /**
+     * Configure whether or not the shell should throw an exception on non-zero exit codes.
+     */
+    throws(shouldThrow: boolean): BunShell;
+}
+export interface BunShellPromise extends Promise<BunShellOutput> {
+    readonly stdin: WritableStream;
+    /**
+     * Change the current working directory of the shell.
+     */
+    cwd(newCwd: string): this;
+    /**
+     * Set environment variables for the shell.
+     */
+    env(newEnv: Record<string, string> | undefined): this;
+    /**
+     * By default, the shell will write to the current process's stdout and stderr, as well as buffering that output.
+     * This configures the shell to only buffer the output.
+     */
+    quiet(): this;
+    /**
+     * Read from stdout as a string, line by line
+     * Automatically calls quiet() to disable echoing to stdout.
+     */
+    lines(): AsyncIterable<string>;
+    /**
+     * Read from stdout as a string.
+     * Automatically calls quiet() to disable echoing to stdout.
+     */
+    text(encoding?: BufferEncoding): Promise<string>;
+    /**
+     * Read from stdout as a JSON object
+     * Automatically calls quiet()
+     */
+    json(): Promise<any>;
+    /**
+     * Read from stdout as an ArrayBuffer
+     * Automatically calls quiet()
+     */
+    arrayBuffer(): Promise<ArrayBuffer>;
+    /**
+     * Read from stdout as a Blob
+     * Automatically calls quiet()
+     */
+    blob(): Promise<Blob>;
+    /**
+     * Configure the shell to not throw an exception on non-zero exit codes.
+     */
+    nothrow(): this;
+    /**
+     * Configure whether or not the shell should throw an exception on non-zero exit codes.
+     */
+    throws(shouldThrow: boolean): this;
+}
+export interface BunShellOutput {
+    readonly stdout: Buffer;
+    readonly stderr: Buffer;
+    readonly exitCode: number;
+    /**
+     * Read from stdout as a string
+     */
+    text(encoding?: BufferEncoding): string;
+    /**
+     * Read from stdout as a JSON object
+     */
+    json(): any;
+    /**
+     * Read from stdout as an ArrayBuffer
+     */
+    arrayBuffer(): ArrayBuffer;
+    /**
+     * Read from stdout as an Uint8Array
+     */
+    bytes(): Uint8Array;
+    /**
+     * Read from stdout as a Blob
+     */
+    blob(): Blob;
+}
+export type BunShellError = Error & BunShellOutput;

data/.opencode/node_modules/@opencode-ai/plugin/dist/tool.d.ts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+export type ToolContext = {
+    sessionID: string;
+    messageID: string;
+    agent: string;
+    /**
+     * Current project directory for this session.
+     * Prefer this over process.cwd() when resolving relative paths.
+     */
+    directory: string;
+    /**
+     * Project worktree root for this session.
+     * Useful for generating stable relative paths (e.g. path.relative(worktree, absPath)).
+     */
+    worktree: string;
+    abort: AbortSignal;
+    metadata(input: {
+        title?: string;
+        metadata?: {
+            [key: string]: any;
+        };
+    }): void;
+    ask(input: AskInput): Promise<void>;
+};
+type AskInput = {
+    permission: string;
+    patterns: string[];
+    always: string[];
+    metadata: {
+        [key: string]: any;
+    };
+};
+export declare function tool<Args extends z.ZodRawShape>(input: {
+    description: string;
+    args: Args;
+    execute(args: z.infer<z.ZodObject<Args>>, context: ToolContext): Promise<string>;
+}): {
+    description: string;
+    args: Args;
+    execute(args: z.infer<z.ZodObject<Args>>, context: ToolContext): Promise<string>;
+};
+export declare namespace tool {
+    var schema: typeof z;
+}
+export type ToolDefinition = ReturnType<typeof tool>;
+export {};

data/.opencode/node_modules/@opencode-ai/plugin/dist/tool.js

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export function tool(input) {
+    return input;
+}
+tool.schema = z;

data/.opencode/node_modules/@opencode-ai/plugin/package.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@opencode-ai/plugin",
+  "version": "1.2.24",
+  "type": "module",
+  "license": "MIT",
+  "scripts": {
+    "typecheck": "tsgo --noEmit",
+    "build": "tsc"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./tool": {
+      "import": "./dist/tool.js",
+      "types": "./dist/tool.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@opencode-ai/sdk": "1.2.24",
+    "zod": "4.1.8"
+  },
+  "devDependencies": {
+    "@tsconfig/node22": "22.0.2",
+    "@types/node": "22.13.9",
+    "typescript": "5.8.2",
+    "@typescript/native-preview": "7.0.0-dev.20251207.1"
+  }
+}

data/.opencode/node_modules/@opencode-ai/sdk/dist/client.d.ts

@@ -0,0 +1,7 @@
+export * from "./gen/types.gen.js";
+import { type Config } from "./gen/client/types.gen.js";
+import { OpencodeClient } from "./gen/sdk.gen.js";
+export { type Config as OpencodeClientConfig, OpencodeClient };
+export declare function createOpencodeClient(config?: Config & {
+    directory?: string;
+}): OpencodeClient;

data/.opencode/node_modules/@opencode-ai/sdk/dist/client.js

@@ -0,0 +1,25 @@
+export * from "./gen/types.gen.js";
+import { createClient } from "./gen/client/client.gen.js";
+import { OpencodeClient } from "./gen/sdk.gen.js";
+export { OpencodeClient };
+export function createOpencodeClient(config) {
+    if (!config?.fetch) {
+        const customFetch = (req) => {
+            // @ts-ignore
+            req.timeout = false;
+            return fetch(req);
+        };
+        config = {
+            ...config,
+            fetch: customFetch,
+        };
+    }
+    if (config?.directory) {
+        config.headers = {
+            ...config.headers,
+            "x-opencode-directory": encodeURIComponent(config.directory),
+        };
+    }
+    const client = createClient(config);
+    return new OpencodeClient({ client });
+}

data/.opencode/node_modules/@opencode-ai/sdk/dist/gen/client/client.gen.d.ts

@@ -0,0 +1,2 @@
+import type { Client, Config } from "./types.gen.js";
+export declare const createClient: (config?: Config) => Client;

data/.opencode/node_modules/@opencode-ai/sdk/dist/gen/client/client.gen.js

@@ -0,0 +1,165 @@
+// This file is auto-generated by @hey-api/openapi-ts
+import { createSseClient } from "../core/serverSentEvents.gen.js";
+import { buildUrl, createConfig, createInterceptors, getParseAs, mergeConfigs, mergeHeaders, setAuthParams, } from "./utils.gen.js";
+export const createClient = (config = {}) => {
+    let _config = mergeConfigs(createConfig(), config);
+    const getConfig = () => ({ ..._config });
+    const setConfig = (config) => {
+        _config = mergeConfigs(_config, config);
+        return getConfig();
+    };
+    const interceptors = createInterceptors();
+    const beforeRequest = async (options) => {
+        const opts = {
+            ..._config,
+            ...options,
+            fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+            headers: mergeHeaders(_config.headers, options.headers),
+            serializedBody: undefined,
+        };
+        if (opts.security) {
+            await setAuthParams({
+                ...opts,
+                security: opts.security,
+            });
+        }
+        if (opts.requestValidator) {
+            await opts.requestValidator(opts);
+        }
+        if (opts.body && opts.bodySerializer) {
+            opts.serializedBody = opts.bodySerializer(opts.body);
+        }
+        // remove Content-Type header if body is empty to avoid sending invalid requests
+        if (opts.serializedBody === undefined || opts.serializedBody === "") {
+            opts.headers.delete("Content-Type");
+        }
+        const url = buildUrl(opts);
+        return { opts, url };
+    };
+    const request = async (options) => {
+        // @ts-expect-error
+        const { opts, url } = await beforeRequest(options);
+        const requestInit = {
+            redirect: "follow",
+            ...opts,
+            body: opts.serializedBody,
+        };
+        let request = new Request(url, requestInit);
+        for (const fn of interceptors.request._fns) {
+            if (fn) {
+                request = await fn(request, opts);
+            }
+        }
+        // fetch must be assigned here, otherwise it would throw the error:
+        // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+        const _fetch = opts.fetch;
+        let response = await _fetch(request);
+        for (const fn of interceptors.response._fns) {
+            if (fn) {
+                response = await fn(response, request, opts);
+            }
+        }
+        const result = {
+            request,
+            response,
+        };
+        if (response.ok) {
+            if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+                return opts.responseStyle === "data"
+                    ? {}
+                    : {
+                        data: {},
+                        ...result,
+                    };
+            }
+            const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+            let data;
+            switch (parseAs) {
+                case "arrayBuffer":
+                case "blob":
+                case "formData":
+                case "json":
+                case "text":
+                    data = await response[parseAs]();
+                    break;
+                case "stream":
+                    return opts.responseStyle === "data"
+                        ? response.body
+                        : {
+                            data: response.body,
+                            ...result,
+                        };
+            }
+            if (parseAs === "json") {
+                if (opts.responseValidator) {
+                    await opts.responseValidator(data);
+                }
+                if (opts.responseTransformer) {
+                    data = await opts.responseTransformer(data);
+                }
+            }
+            return opts.responseStyle === "data"
+                ? data
+                : {
+                    data,
+                    ...result,
+                };
+        }
+        const textError = await response.text();
+        let jsonError;
+        try {
+            jsonError = JSON.parse(textError);
+        }
+        catch {
+            // noop
+        }
+        const error = jsonError ?? textError;
+        let finalError = error;
+        for (const fn of interceptors.error._fns) {
+            if (fn) {
+                finalError = (await fn(error, response, request, opts));
+            }
+        }
+        finalError = finalError || {};
+        if (opts.throwOnError) {
+            throw finalError;
+        }
+        // TODO: we probably want to return error and improve types
+        return opts.responseStyle === "data"
+            ? undefined
+            : {
+                error: finalError,
+                ...result,
+            };
+    };
+    const makeMethod = (method) => {
+        const fn = (options) => request({ ...options, method });
+        fn.sse = async (options) => {
+            const { opts, url } = await beforeRequest(options);
+            return createSseClient({
+                ...opts,
+                body: opts.body,
+                headers: opts.headers,
+                method,
+                url,
+            });
+        };
+        return fn;
+    };
+    return {
+        buildUrl,
+        connect: makeMethod("CONNECT"),
+        delete: makeMethod("DELETE"),
+        get: makeMethod("GET"),
+        getConfig,
+        head: makeMethod("HEAD"),
+        interceptors,
+        options: makeMethod("OPTIONS"),
+        patch: makeMethod("PATCH"),
+        post: makeMethod("POST"),
+        put: makeMethod("PUT"),
+        request,
+        setConfig,
+        trace: makeMethod("TRACE"),
+    };
+};

data/.opencode/node_modules/@opencode-ai/sdk/dist/gen/client/index.d.ts

@@ -0,0 +1,7 @@
+export type { Auth } from "../core/auth.gen.js";
+export type { QuerySerializerOptions } from "../core/bodySerializer.gen.js";
+export { formDataBodySerializer, jsonBodySerializer, urlSearchParamsBodySerializer, } from "../core/bodySerializer.gen.js";
+export { buildClientParams } from "../core/params.gen.js";
+export { createClient } from "./client.gen.js";
+export type { Client, ClientOptions, Config, CreateClientConfig, Options, OptionsLegacyParser, RequestOptions, RequestResult, ResolvedRequestOptions, ResponseStyle, TDataShape, } from "./types.gen.js";
+export { createConfig, mergeHeaders } from "./utils.gen.js";

data/.opencode/node_modules/@opencode-ai/sdk/dist/gen/client/index.js

@@ -0,0 +1,5 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export { formDataBodySerializer, jsonBodySerializer, urlSearchParamsBodySerializer, } from "../core/bodySerializer.gen.js";
+export { buildClientParams } from "../core/params.gen.js";
+export { createClient } from "./client.gen.js";
+export { createConfig, mergeHeaders } from "./utils.gen.js";