@neurocode-ai/plugin 1.18.13 → 1.18.15

package/src/v2/effect/context.ts

@@ -0,0 +1,22 @@
+import type { PluginOptions } from "../options.js"
+import type { AgentHooks } from "./agent.js"
+import type { AISDKHooks } from "./aisdk.js"
+import type { CatalogHooks } from "./catalog.js"
+import type { CommandHooks } from "./command.js"
+import type { IntegrationHooks } from "./integration.js"
+import type { PluginDomain } from "./plugin.js"
+import type { ReferenceHooks } from "./reference.js"
+import type { SkillHooks } from "./skill.js"
+import type { Reload } from "./registration.js"
+
+export interface PluginContext {
+  readonly options: PluginOptions
+  readonly agent: AgentHooks & Reload
+  readonly aisdk: AISDKHooks
+  readonly catalog: CatalogHooks & Reload
+  readonly command: CommandHooks & Reload
+  readonly integration: IntegrationHooks & Reload
+  readonly plugin: PluginDomain
+  readonly reference: ReferenceHooks & Reload
+  readonly skill: SkillHooks & Reload
+}

package/src/v2/effect/event.ts

@@ -0,0 +1,10 @@
+import type { Event as SDKEvent } from "@neurocode-ai/sdk/v2/types"
+import type { Stream } from "effect"
+
+export type EventMap = {
+  [Item in SDKEvent as Item["type"]]: Item
+}
+
+export interface Event {
+  subscribe<Type extends keyof EventMap>(type: Type): Stream.Stream<EventMap[Type]>
+}

package/src/v2/effect/filesystem.ts

@@ -0,0 +1,17 @@
+import type { FileSystemEntry } from "@neurocode-ai/sdk/v2/types"
+import type { Effect } from "effect"
+
+export interface FileSystem {
+  read(input: { readonly path: string }): Effect.Effect<{ readonly content: Uint8Array; readonly mime: string }>
+  list(input?: { readonly path?: string }): Effect.Effect<FileSystemEntry[]>
+  find(input: {
+    readonly query: string
+    readonly type?: "file" | "directory"
+    readonly limit?: number
+  }): Effect.Effect<FileSystemEntry[]>
+  glob(input: {
+    readonly pattern: string
+    readonly path?: string
+    readonly limit?: number
+  }): Effect.Effect<readonly FileSystemEntry[]>
+}

package/src/v2/effect/index.ts

@@ -0,0 +1,3 @@
+export type { PluginContext } from "./context.js"
+export { define } from "./plugin.js"
+export type { Plugin } from "./plugin.js"

package/src/v2/effect/integration.ts

@@ -0,0 +1,63 @@
+import type {
+  ConnectionInfo,
+  CredentialOAuth,
+  CredentialValue,
+  IntegrationEnvMethod,
+  IntegrationInputs,
+  IntegrationKeyMethod,
+  IntegrationMethod,
+  IntegrationOAuthMethod,
+  IntegrationRef,
+} from "@neurocode-ai/sdk/v2/types"
+import type { Effect, Scope } from "effect"
+import type { Hooks } from "./registration.js"
+
+export type IntegrationOAuthAuthorization = {
+  readonly url: string
+  readonly instructions: string
+} & (
+  | {
+      readonly mode: "auto"
+      readonly callback: Effect.Effect<CredentialOAuth, unknown>
+    }
+  | {
+      readonly mode: "code"
+      readonly callback: (code: string) => Effect.Effect<CredentialOAuth, unknown>
+    }
+)
+export type IntegrationOAuthMethodRegistration = {
+  readonly integrationID: string
+  readonly method: IntegrationOAuthMethod
+  readonly authorize: (inputs: IntegrationInputs) => Effect.Effect<IntegrationOAuthAuthorization, unknown, Scope.Scope>
+  readonly refresh?: (credential: CredentialOAuth) => Effect.Effect<CredentialOAuth, unknown>
+  readonly label?: (credential: CredentialOAuth) => string | undefined
+}
+export type IntegrationMethodRegistration =
+  | IntegrationOAuthMethodRegistration
+  | {
+      readonly integrationID: string
+      readonly method: IntegrationKeyMethod
+    }
+  | {
+      readonly integrationID: string
+      readonly method: IntegrationEnvMethod
+    }
+
+export interface IntegrationDraft {
+  list(): readonly IntegrationRef[]
+  get(id: string): IntegrationRef | undefined
+  update(id: string, update: (integration: IntegrationRef) => void): void
+  remove(id: string): void
+  readonly method: {
+    list(integrationID: string): readonly IntegrationMethod[]
+    update(input: IntegrationMethodRegistration): void
+    remove(integrationID: string, method: IntegrationMethod): void
+  }
+}
+
+export interface IntegrationHooks extends Hooks<{ transform: IntegrationDraft }> {
+  readonly connection: {
+    readonly active: (integrationID: string) => Effect.Effect<ConnectionInfo | undefined>
+    readonly resolve: (connection: ConnectionInfo) => Effect.Effect<CredentialValue | undefined, unknown>
+  }
+}

package/src/v2/effect/location.ts

@@ -0,0 +1,6 @@
+export interface Location {
+  readonly directory: string
+  readonly project: {
+    readonly directory: string
+  }
+}

package/src/v2/effect/npm.ts

@@ -0,0 +1,11 @@
+import type { Effect } from "effect"
+
+export interface Npm {
+  add(pkg: string): Effect.Effect<
+    {
+      readonly directory: string
+      readonly entrypoint?: string
+    },
+    unknown
+  >
+}

package/src/v2/effect/path.ts

@@ -0,0 +1,8 @@
+export interface Path {
+  readonly home: string
+  readonly data: string
+  readonly cache: string
+  readonly config: string
+  readonly state: string
+  readonly temp: string
+}

package/src/v2/effect/plugin.ts

@@ -0,0 +1,16 @@
+import type { Effect, Scope } from "effect"
+import type { PluginContext } from "./context.js"
+
+export interface Plugin<R = Scope.Scope> {
+  readonly id: string
+  readonly effect: (context: PluginContext) => Effect.Effect<void, never, R>
+}
+
+export function define<R = Scope.Scope>(plugin: Plugin<R>) {
+  return plugin
+}
+
+export interface PluginDomain {
+  readonly add: (plugin: Plugin) => Effect.Effect<void>
+  readonly remove: (id: string) => Effect.Effect<void>
+}

package/src/v2/effect/reference.ts

@@ -0,0 +1,12 @@
+import type { ReferenceGitSource, ReferenceLocalSource } from "@neurocode-ai/sdk/v2/types"
+import type { Hooks } from "./registration.js"
+
+export interface ReferenceDraft {
+  add(name: string, source: ReferenceLocalSource | ReferenceGitSource): void
+  remove(name: string): void
+  list(): readonly (readonly [string, ReferenceLocalSource | ReferenceGitSource])[]
+}
+
+export type ReferenceHooks = Hooks<{
+  transform: ReferenceDraft
+}>

package/src/v2/effect/registration.ts

@@ -0,0 +1,15 @@
+import type { Effect, Scope } from "effect"
+
+export interface Registration {
+  readonly dispose: Effect.Effect<void>
+}
+
+export interface Reload {
+  readonly reload: () => Effect.Effect<void>
+}
+
+export type Hooks<Spec> = {
+  readonly [Name in keyof Spec]: (
+    callback: (input: Spec[Name]) => Effect.Effect<void> | void,
+  ) => Effect.Effect<Registration, never, Scope.Scope>
+}

package/src/v2/effect/skill.ts

@@ -0,0 +1,11 @@
+import type { SkillV2Source } from "@neurocode-ai/sdk/v2/types"
+import type { Hooks } from "./registration.js"
+
+export interface SkillDraft {
+  source(source: SkillV2Source): void
+  list(): readonly SkillV2Source[]
+}
+
+export type SkillHooks = Hooks<{
+  transform: SkillDraft
+}>

package/src/v2/options.ts

@@ -0,0 +1 @@
+export type PluginOptions = Readonly<Record<string, any>>

package/src/v2/promise/README.md

@@ -0,0 +1,103 @@
+# OpenCode V2 Promise Plugin API
+
+The Promise plugin API is the async/await equivalent of `@opencode-ai/plugin/v2/effect`. It grants plugins the same two in-process capabilities:
+
+- `hook` installs behavior at an OpenCode extension point.
+- `reload` reruns every transform hook for a stateful domain.
+
+The only difference from the Effect API is the async boundary: hook callbacks, hook registration, `reload`, and `Registration.dispose` use Promises instead of Effects.
+
+## Defining A Plugin
+
+```ts
+import { define } from "@opencode-ai/plugin/v2/promise"
+
+export const Plugin = define({
+  id: "example",
+  setup: async (ctx) => {
+    await ctx.catalog.transform((catalog) => {
+      catalog.provider.update("example", (provider) => {
+        provider.name = "Example"
+      })
+    })
+  },
+})
+```
+
+Plugin setup registers hooks imperatively. It does not return a hook object.
+
+Configuration supplied for the plugin is available as `ctx.options`.
+
+A registration may be removed early through `dispose`:
+
+```ts
+const registration = await ctx.catalog.transform(applyCatalog)
+await registration.dispose()
+```
+
+## Transform Hooks
+
+Transform hooks contribute to stateful domains. The draft editor is synchronous; the callback may be `async` when it needs to await other work:
+
+```ts
+await ctx.agent.transform((agent) => {
+  agent.update("reviewer", (item) => {
+    item.description = "Reviews code for regressions"
+    item.mode = "subagent"
+  })
+})
+```
+
+Available transform hooks are namespaced by domain:
+
+```ts
+ctx.agent.transform
+ctx.catalog.transform
+ctx.command.transform
+ctx.integration.transform
+ctx.reference.transform
+ctx.skill.transform
+```
+
+## Runtime Hooks
+
+Runtime hooks intercept live operations:
+
+```ts
+await ctx.aisdk.sdk(async (event) => {
+  if (event.package !== "@ai-sdk/xai") return
+  const mod = await import("@ai-sdk/xai")
+  event.sdk = mod.createXai(event.options)
+})
+
+await ctx.aisdk.language((event) => {
+  if (event.model.providerID !== "xai") return
+  event.language = event.sdk.responses(event.model.api.id)
+})
+```
+
+## Reloading A Domain
+
+When data captured by a transform changes, reload the affected domain:
+
+```ts
+let data = await loadCatalog()
+
+await ctx.catalog.transform((catalog) => {
+  applyCatalog(data, catalog)
+})
+
+data = await loadCatalog()
+await ctx.catalog.reload()
+```
+
+Available reload operations are:
+
+```ts
+ctx.agent.reload()
+ctx.catalog.reload()
+ctx.command.reload()
+ctx.integration.reload()
+ctx.reference.reload()
+ctx.skill.reload()
+```

package/src/v2/promise/agent.ts

@@ -0,0 +1,8 @@
+import type { AgentDraft } from "../effect/agent.js"
+import type { Hooks } from "./registration.js"
+
+export type { AgentDraft }
+
+export type AgentHooks = Hooks<{
+  transform: AgentDraft
+}>

package/src/v2/promise/aisdk.ts

@@ -0,0 +1,18 @@
+import type { LanguageModelV3 } from "@ai-sdk/provider"
+import type { ModelV2Info } from "@neurocode-ai/sdk/v2/types"
+import type { Hooks } from "./registration.js"
+
+export type AISDKHooks = Hooks<{
+  sdk: {
+    readonly model: ModelV2Info
+    readonly package: string
+    readonly options: Record<string, any>
+    sdk?: any
+  }
+  language: {
+    readonly model: ModelV2Info
+    readonly sdk: any
+    readonly options: Record<string, any>
+    language?: LanguageModelV3
+  }
+}>

package/src/v2/promise/catalog.ts

@@ -0,0 +1,8 @@
+import type { CatalogDraft, CatalogProviderRecord } from "../effect/catalog.js"
+import type { Hooks } from "./registration.js"
+
+export type { CatalogDraft, CatalogProviderRecord }
+
+export type CatalogHooks = Hooks<{
+  transform: CatalogDraft
+}>

package/src/v2/promise/command.ts

@@ -0,0 +1,8 @@
+import type { CommandDraft } from "../effect/command.js"
+import type { Hooks } from "./registration.js"
+
+export type { CommandDraft }
+
+export type CommandHooks = Hooks<{
+  transform: CommandDraft
+}>

package/src/v2/promise/context.ts

@@ -0,0 +1,22 @@
+import type { PluginOptions } from "../options.js"
+import type { AgentHooks } from "./agent.js"
+import type { AISDKHooks } from "./aisdk.js"
+import type { CatalogHooks } from "./catalog.js"
+import type { CommandHooks } from "./command.js"
+import type { IntegrationHooks } from "./integration.js"
+import type { PluginDomain } from "./plugin.js"
+import type { ReferenceHooks } from "./reference.js"
+import type { SkillHooks } from "./skill.js"
+import type { Reload } from "./registration.js"
+
+export interface PluginContext {
+  readonly options: PluginOptions
+  readonly agent: AgentHooks & Reload
+  readonly aisdk: AISDKHooks
+  readonly catalog: CatalogHooks & Reload
+  readonly command: CommandHooks & Reload
+  readonly integration: IntegrationHooks & Reload
+  readonly plugin: PluginDomain
+  readonly reference: ReferenceHooks & Reload
+  readonly skill: SkillHooks & Reload
+}

package/src/v2/promise/index.ts

@@ -0,0 +1,12 @@
+export type { PluginContext } from "./context.js"
+export type { PluginOptions } from "../options.js"
+export { define } from "./plugin.js"
+export type { Plugin, PluginDomain } from "./plugin.js"
+export type { Registration, Reload } from "./registration.js"
+export type { AgentDraft, AgentHooks } from "./agent.js"
+export type { AISDKHooks } from "./aisdk.js"
+export type { CatalogDraft, CatalogHooks, CatalogProviderRecord } from "./catalog.js"
+export type { CommandDraft, CommandHooks } from "./command.js"
+export type { IntegrationDraft, IntegrationHooks, IntegrationMethodRegistration } from "./integration.js"
+export type { ReferenceDraft, ReferenceHooks } from "./reference.js"
+export type { SkillDraft, SkillHooks } from "./skill.js"

package/src/v2/promise/integration.ts

@@ -0,0 +1,14 @@
+import type { IntegrationDraft, IntegrationMethodRegistration } from "../effect/integration.js"
+import type { CredentialValue } from "@neurocode-ai/sdk/v2/types"
+import type { Hooks } from "./registration.js"
+
+export type { IntegrationDraft, IntegrationMethodRegistration }
+
+export interface IntegrationHooks extends Hooks<{ transform: IntegrationDraft }> {
+  readonly connection: {
+    readonly active: (integrationID: string) => Promise<import("@neurocode-ai/sdk/v2/types").ConnectionInfo | undefined>
+    readonly resolve: (
+      connection: import("@neurocode-ai/sdk/v2/types").ConnectionInfo,
+    ) => Promise<CredentialValue | undefined>
+  }
+}

package/src/v2/promise/plugin.ts

@@ -0,0 +1,15 @@
+import type { PluginContext } from "./context.js"
+
+export interface Plugin {
+  readonly id: string
+  readonly setup: (context: PluginContext) => Promise<void> | void
+}
+
+export function define(plugin: Plugin) {
+  return plugin
+}
+
+export interface PluginDomain {
+  readonly add: (plugin: Plugin) => Promise<void>
+  readonly remove: (id: string) => Promise<void>
+}

package/src/v2/promise/reference.ts

@@ -0,0 +1,8 @@
+import type { ReferenceDraft } from "../effect/reference.js"
+import type { Hooks } from "./registration.js"
+
+export type { ReferenceDraft }
+
+export type ReferenceHooks = Hooks<{
+  transform: ReferenceDraft
+}>

package/src/v2/promise/registration.ts

@@ -0,0 +1,11 @@
+export interface Registration {
+  readonly dispose: () => Promise<void>
+}
+
+export interface Reload {
+  readonly reload: () => Promise<void>
+}
+
+export type Hooks<Spec> = {
+  readonly [Name in keyof Spec]: (callback: (input: Spec[Name]) => Promise<void> | void) => Promise<Registration>
+}

package/src/v2/promise/skill.ts

@@ -0,0 +1,8 @@
+import type { SkillDraft } from "../effect/skill.js"
+import type { Hooks } from "./registration.js"
+
+export type { SkillDraft }
+
+export type SkillHooks = Hooks<{
+  transform: SkillDraft
+}>