bonecode 1.0.0 → 1.2.0

package/src/engine/config/mcp.ts

@@ -1,56 +1,56 @@
-import { Schema } from "effect"
-import { PositiveInt } from "@opencode-ai/core/schema"
-
-export const Local = Schema.Struct({
-  type: Schema.Literal("local").annotate({ description: "Type of MCP server connection" }),
-  command: Schema.mutable(Schema.Array(Schema.String)).annotate({
-    description: "Command and arguments to run the MCP server",
-  }),
-  environment: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({
-    description: "Environment variables to set when running the MCP server",
-  }),
-  enabled: Schema.optional(Schema.Boolean).annotate({
-    description: "Enable or disable the MCP server on startup",
-  }),
-  timeout: Schema.optional(PositiveInt).annotate({
-    description: "Timeout in ms for MCP server requests. Defaults to 5000 (5 seconds) if not specified.",
-  }),
-}).annotate({ identifier: "McpLocalConfig" })
-export type Local = Schema.Schema.Type<typeof Local>
-
-export const OAuth = Schema.Struct({
-  clientId: Schema.optional(Schema.String).annotate({
-    description: "OAuth client ID. If not provided, dynamic client registration (RFC 7591) will be attempted.",
-  }),
-  clientSecret: Schema.optional(Schema.String).annotate({
-    description: "OAuth client secret (if required by the authorization server)",
-  }),
-  scope: Schema.optional(Schema.String).annotate({ description: "OAuth scopes to request during authorization" }),
-  redirectUri: Schema.optional(Schema.String).annotate({
-    description: "OAuth redirect URI (default: http://127.0.0.1:19876/mcp/oauth/callback).",
-  }),
-}).annotate({ identifier: "McpOAuthConfig" })
-export type OAuth = Schema.Schema.Type<typeof OAuth>
-
-export const Remote = Schema.Struct({
-  type: Schema.Literal("remote").annotate({ description: "Type of MCP server connection" }),
-  url: Schema.String.annotate({ description: "URL of the remote MCP server" }),
-  enabled: Schema.optional(Schema.Boolean).annotate({
-    description: "Enable or disable the MCP server on startup",
-  }),
-  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({
-    description: "Headers to send with the request",
-  }),
-  oauth: Schema.optional(Schema.Union([OAuth, Schema.Literal(false)])).annotate({
-    description: "OAuth authentication configuration for the MCP server. Set to false to disable OAuth auto-detection.",
-  }),
-  timeout: Schema.optional(PositiveInt).annotate({
-    description: "Timeout in ms for MCP server requests. Defaults to 5000 (5 seconds) if not specified.",
-  }),
-}).annotate({ identifier: "McpRemoteConfig" })
-export type Remote = Schema.Schema.Type<typeof Remote>
-
-export const Info = Schema.Union([Local, Remote]).annotate({ discriminator: "type" })
-export type Info = Schema.Schema.Type<typeof Info>
-
-export * as ConfigMCP from "./mcp"
+import { Schema } from "effect"
+import { PositiveInt } from "@opencode-ai/core/schema"
+
+export const Local = Schema.Struct({
+  type: Schema.Literal("local").annotate({ description: "Type of MCP server connection" }),
+  command: Schema.mutable(Schema.Array(Schema.String)).annotate({
+    description: "Command and arguments to run the MCP server",
+  }),
+  environment: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({
+    description: "Environment variables to set when running the MCP server",
+  }),
+  enabled: Schema.optional(Schema.Boolean).annotate({
+    description: "Enable or disable the MCP server on startup",
+  }),
+  timeout: Schema.optional(PositiveInt).annotate({
+    description: "Timeout in ms for MCP server requests. Defaults to 5000 (5 seconds) if not specified.",
+  }),
+}).annotate({ identifier: "McpLocalConfig" })
+export type Local = Schema.Schema.Type<typeof Local>
+
+export const OAuth = Schema.Struct({
+  clientId: Schema.optional(Schema.String).annotate({
+    description: "OAuth client ID. If not provided, dynamic client registration (RFC 7591) will be attempted.",
+  }),
+  clientSecret: Schema.optional(Schema.String).annotate({
+    description: "OAuth client secret (if required by the authorization server)",
+  }),
+  scope: Schema.optional(Schema.String).annotate({ description: "OAuth scopes to request during authorization" }),
+  redirectUri: Schema.optional(Schema.String).annotate({
+    description: "OAuth redirect URI (default: http://127.0.0.1:19876/mcp/oauth/callback).",
+  }),
+}).annotate({ identifier: "McpOAuthConfig" })
+export type OAuth = Schema.Schema.Type<typeof OAuth>
+
+export const Remote = Schema.Struct({
+  type: Schema.Literal("remote").annotate({ description: "Type of MCP server connection" }),
+  url: Schema.String.annotate({ description: "URL of the remote MCP server" }),
+  enabled: Schema.optional(Schema.Boolean).annotate({
+    description: "Enable or disable the MCP server on startup",
+  }),
+  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({
+    description: "Headers to send with the request",
+  }),
+  oauth: Schema.optional(Schema.Union([OAuth, Schema.Literal(false)])).annotate({
+    description: "OAuth authentication configuration for the MCP server. Set to false to disable OAuth auto-detection.",
+  }),
+  timeout: Schema.optional(PositiveInt).annotate({
+    description: "Timeout in ms for MCP server requests. Defaults to 5000 (5 seconds) if not specified.",
+  }),
+}).annotate({ identifier: "McpRemoteConfig" })
+export type Remote = Schema.Schema.Type<typeof Remote>
+
+export const Info = Schema.Union([Local, Remote]).annotate({ discriminator: "type" })
+export type Info = Schema.Schema.Type<typeof Info>
+
+export * as ConfigMCP from "./mcp"

package/src/engine/config/model-id.ts

@@ -1,5 +1,5 @@
-import { Schema } from "effect"
-
-export const ConfigModelID = Schema.String
-
-export type ConfigModelID = Schema.Schema.Type<typeof ConfigModelID>
+import { Schema } from "effect"
+
+export const ConfigModelID = Schema.String
+
+export type ConfigModelID = Schema.Schema.Type<typeof ConfigModelID>

package/src/engine/config/parse.ts

@@ -1,79 +1,79 @@
-export * as ConfigParse from "./parse"
-
-import { type ParseError as JsoncParseError, parse as parseJsoncImpl, printParseErrorCode } from "jsonc-parser"
-import { Cause, Exit, Schema as EffectSchema, SchemaIssue } from "effect"
-import type { DeepMutable } from "@opencode-ai/core/schema"
-import { InvalidError, JsonError } from "./error"
-
-export function jsonc(text: string, filepath: string): unknown {
-  const errors: JsoncParseError[] = []
-  const data = parseJsoncImpl(text, errors, { allowTrailingComma: true })
-  if (errors.length) {
-    const lines = text.split("\n")
-    const issues = errors
-      .map((e) => {
-        const beforeOffset = text.substring(0, e.offset).split("\n")
-        const line = beforeOffset.length
-        const column = beforeOffset[beforeOffset.length - 1].length + 1
-        const problemLine = lines[line - 1]
-
-        const error = `${printParseErrorCode(e.error)} at line ${line}, column ${column}`
-        if (!problemLine) return error
-
-        return `${error}\n   Line ${line}: ${problemLine}\n${"".padStart(column + 9)}^`
-      })
-      .join("\n")
-    throw new JsonError({
-      path: filepath,
-      message: `\n--- JSONC Input ---\n${text}\n--- Errors ---\n${issues}\n--- End ---`,
-    })
-  }
-
-  return data
-}
-
-export function schema<S extends EffectSchema.Decoder<unknown, never>>(
-  schema: S,
-  data: unknown,
-  source: string,
-): DeepMutable<S["Type"]> {
-  const extra = topLevelExtraKeys(schema, data)
-  if (extra.length) {
-    throw new InvalidError({
-      path: source,
-      issues: [
-        {
-          code: "unrecognized_keys",
-          keys: extra,
-          path: [],
-          message: `Unrecognized key${extra.length === 1 ? "" : "s"}: ${extra.join(", ")}`,
-        },
-      ],
-    })
-  }
-
-  const decoded = EffectSchema.decodeUnknownExit(schema)(data, { errors: "all", propertyOrder: "original" })
-  if (Exit.isSuccess(decoded)) return decoded.value as DeepMutable<S["Type"]>
-  const error = Cause.squash(decoded.cause)
-
-  throw new InvalidError(
-    {
-      path: source,
-      issues: EffectSchema.isSchemaError(error)
-        ? SchemaIssue.makeFormatterStandardSchemaV1()(error.issue).issues.map((issue) => ({
-            ...issue,
-            message: issue.message,
-            path: issue.path?.map(String) ?? [],
-          }))
-        : [{ message: String(error), path: [] }],
-    },
-    { cause: error },
-  )
-}
-
-function topLevelExtraKeys(schema: EffectSchema.Top, data: unknown) {
-  if (typeof data !== "object" || data === null || Array.isArray(data)) return []
-  if (schema.ast._tag !== "Objects" || schema.ast.indexSignatures.length > 0) return []
-  const known = new Set(schema.ast.propertySignatures.map((item) => String(item.name)))
-  return Object.keys(data).filter((key) => !known.has(key))
-}
+export * as ConfigParse from "./parse"
+
+import { type ParseError as JsoncParseError, parse as parseJsoncImpl, printParseErrorCode } from "jsonc-parser"
+import { Cause, Exit, Schema as EffectSchema, SchemaIssue } from "effect"
+import type { DeepMutable } from "@opencode-ai/core/schema"
+import { InvalidError, JsonError } from "./error"
+
+export function jsonc(text: string, filepath: string): unknown {
+  const errors: JsoncParseError[] = []
+  const data = parseJsoncImpl(text, errors, { allowTrailingComma: true })
+  if (errors.length) {
+    const lines = text.split("\n")
+    const issues = errors
+      .map((e) => {
+        const beforeOffset = text.substring(0, e.offset).split("\n")
+        const line = beforeOffset.length
+        const column = beforeOffset[beforeOffset.length - 1].length + 1
+        const problemLine = lines[line - 1]
+
+        const error = `${printParseErrorCode(e.error)} at line ${line}, column ${column}`
+        if (!problemLine) return error
+
+        return `${error}\n   Line ${line}: ${problemLine}\n${"".padStart(column + 9)}^`
+      })
+      .join("\n")
+    throw new JsonError({
+      path: filepath,
+      message: `\n--- JSONC Input ---\n${text}\n--- Errors ---\n${issues}\n--- End ---`,
+    })
+  }
+
+  return data
+}
+
+export function schema<S extends EffectSchema.Decoder<unknown, never>>(
+  schema: S,
+  data: unknown,
+  source: string,
+): DeepMutable<S["Type"]> {
+  const extra = topLevelExtraKeys(schema, data)
+  if (extra.length) {
+    throw new InvalidError({
+      path: source,
+      issues: [
+        {
+          code: "unrecognized_keys",
+          keys: extra,
+          path: [],
+          message: `Unrecognized key${extra.length === 1 ? "" : "s"}: ${extra.join(", ")}`,
+        },
+      ],
+    })
+  }
+
+  const decoded = EffectSchema.decodeUnknownExit(schema)(data, { errors: "all", propertyOrder: "original" })
+  if (Exit.isSuccess(decoded)) return decoded.value as DeepMutable<S["Type"]>
+  const error = Cause.squash(decoded.cause)
+
+  throw new InvalidError(
+    {
+      path: source,
+      issues: EffectSchema.isSchemaError(error)
+        ? SchemaIssue.makeFormatterStandardSchemaV1()(error.issue).issues.map((issue) => ({
+            ...issue,
+            message: issue.message,
+            path: issue.path?.map(String) ?? [],
+          }))
+        : [{ message: String(error), path: [] }],
+    },
+    { cause: error },
+  )
+}
+
+function topLevelExtraKeys(schema: EffectSchema.Top, data: unknown) {
+  if (typeof data !== "object" || data === null || Array.isArray(data)) return []
+  if (schema.ast._tag !== "Objects" || schema.ast.indexSignatures.length > 0) return []
+  const known = new Set(schema.ast.propertySignatures.map((item) => String(item.name)))
+  return Object.keys(data).filter((key) => !known.has(key))
+}

package/src/engine/config/paths.ts

@@ -1,45 +1,45 @@
-export * as ConfigPaths from "./paths"
-
-import path from "path"
-import { Flag } from "@opencode-ai/core/flag/flag"
-import { Global } from "@opencode-ai/core/global"
-import { unique } from "remeda"
-import * as Effect from "effect/Effect"
-import { AppFileSystem } from "@opencode-ai/core/filesystem"
-
-export const files = Effect.fn("ConfigPaths.projectFiles")(function* (
-  name: string,
-  directory: string,
-  worktree?: string,
-) {
-  const afs = yield* AppFileSystem.Service
-  return (yield* afs.up({
-    targets: [`${name}.jsonc`, `${name}.json`],
-    start: directory,
-    stop: worktree,
-  })).toReversed()
-})
-
-export const directories = Effect.fn("ConfigPaths.directories")(function* (directory: string, worktree?: string) {
-  const afs = yield* AppFileSystem.Service
-  return unique([
-    Global.Path.config,
-    ...(!Flag.OPENCODE_DISABLE_PROJECT_CONFIG
-      ? yield* afs.up({
-          targets: [".opencode"],
-          start: directory,
-          stop: worktree,
-        })
-      : []),
-    ...(yield* afs.up({
-      targets: [".opencode"],
-      start: Global.Path.home,
-      stop: Global.Path.home,
-    })),
-    ...(Flag.OPENCODE_CONFIG_DIR ? [Flag.OPENCODE_CONFIG_DIR] : []),
-  ])
-})
-
-export function fileInDirectory(dir: string, name: string) {
-  return [path.join(dir, `${name}.json`), path.join(dir, `${name}.jsonc`)]
-}
+export * as ConfigPaths from "./paths"
+
+import path from "path"
+import { Flag } from "@opencode-ai/core/flag/flag"
+import { Global } from "@opencode-ai/core/global"
+import { unique } from "remeda"
+import * as Effect from "effect/Effect"
+import { AppFileSystem } from "@opencode-ai/core/filesystem"
+
+export const files = Effect.fn("ConfigPaths.projectFiles")(function* (
+  name: string,
+  directory: string,
+  worktree?: string,
+) {
+  const afs = yield* AppFileSystem.Service
+  return (yield* afs.up({
+    targets: [`${name}.jsonc`, `${name}.json`],
+    start: directory,
+    stop: worktree,
+  })).toReversed()
+})
+
+export const directories = Effect.fn("ConfigPaths.directories")(function* (directory: string, worktree?: string) {
+  const afs = yield* AppFileSystem.Service
+  return unique([
+    Global.Path.config,
+    ...(!Flag.OPENCODE_DISABLE_PROJECT_CONFIG
+      ? yield* afs.up({
+          targets: [".opencode"],
+          start: directory,
+          stop: worktree,
+        })
+      : []),
+    ...(yield* afs.up({
+      targets: [".opencode"],
+      start: Global.Path.home,
+      stop: Global.Path.home,
+    })),
+    ...(Flag.OPENCODE_CONFIG_DIR ? [Flag.OPENCODE_CONFIG_DIR] : []),
+  ])
+})
+
+export function fileInDirectory(dir: string, name: string) {
+  return [path.join(dir, `${name}.json`), path.join(dir, `${name}.jsonc`)]
+}

package/src/engine/config/permission.ts

@@ -1,58 +1,58 @@
-export * as ConfigPermission from "./permission"
-import { Schema, SchemaGetter } from "effect"
-
-export const Action = Schema.Literals(["ask", "allow", "deny"]).annotate({ identifier: "PermissionActionConfig" })
-export type Action = Schema.Schema.Type<typeof Action>
-
-export const Object = Schema.Record(Schema.String, Action).annotate({ identifier: "PermissionObjectConfig" })
-export type Object = Schema.Schema.Type<typeof Object>
-
-export const Rule = Schema.Union([Action, Object]).annotate({ identifier: "PermissionRuleConfig" })
-export type Rule = Schema.Schema.Type<typeof Rule>
-
-// Known permission keys get explicit types in the Effect schema for generated
-// docs/types. Runtime config parsing uses Effect's `propertyOrder: "original"`
-// parse option so user key order is preserved for permission precedence.
-const InputObject = Schema.StructWithRest(
-  Schema.Struct({
-    read: Schema.optional(Rule),
-    edit: Schema.optional(Rule),
-    glob: Schema.optional(Rule),
-    grep: Schema.optional(Rule),
-    list: Schema.optional(Rule),
-    bash: Schema.optional(Rule),
-    task: Schema.optional(Rule),
-    external_directory: Schema.optional(Rule),
-    todowrite: Schema.optional(Action),
-    question: Schema.optional(Action),
-    webfetch: Schema.optional(Action),
-    websearch: Schema.optional(Action),
-    repo_clone: Schema.optional(Rule),
-    repo_overview: Schema.optional(Rule),
-    lsp: Schema.optional(Rule),
-    doom_loop: Schema.optional(Action),
-    skill: Schema.optional(Rule),
-  }),
-  [Schema.Record(Schema.String, Rule)],
-)
-
-// Input the user writes in config: either a single Action (shorthand for "*")
-// or an object of per-target rules.
-const InputSchema = Schema.Union([Action, InputObject])
-
-// Normalise the Action shorthand into `{ "*": action }`. Object inputs pass
-// through untouched.
-const normalizeInput = (input: Schema.Schema.Type<typeof InputSchema>): Schema.Schema.Type<typeof InputObject> =>
-  typeof input === "string" ? { "*": input } : input
-
-export const Info = InputSchema.pipe(
-  Schema.decodeTo(InputObject, {
-    decode: SchemaGetter.transform(normalizeInput),
-    // Not perfectly invertible (we lose whether the user originally typed an
-    // Action shorthand), but the object form is always a valid representation
-    // of the same rules.
-    encode: SchemaGetter.passthrough({ strict: false }),
-  }),
-).annotate({ identifier: "PermissionConfig" })
-type _Info = Schema.Schema.Type<typeof InputObject>
-export type Info = { -readonly [K in keyof _Info]: _Info[K] }
+export * as ConfigPermission from "./permission"
+import { Schema, SchemaGetter } from "effect"
+
+export const Action = Schema.Literals(["ask", "allow", "deny"]).annotate({ identifier: "PermissionActionConfig" })
+export type Action = Schema.Schema.Type<typeof Action>
+
+export const Object = Schema.Record(Schema.String, Action).annotate({ identifier: "PermissionObjectConfig" })
+export type Object = Schema.Schema.Type<typeof Object>
+
+export const Rule = Schema.Union([Action, Object]).annotate({ identifier: "PermissionRuleConfig" })
+export type Rule = Schema.Schema.Type<typeof Rule>
+
+// Known permission keys get explicit types in the Effect schema for generated
+// docs/types. Runtime config parsing uses Effect's `propertyOrder: "original"`
+// parse option so user key order is preserved for permission precedence.
+const InputObject = Schema.StructWithRest(
+  Schema.Struct({
+    read: Schema.optional(Rule),
+    edit: Schema.optional(Rule),
+    glob: Schema.optional(Rule),
+    grep: Schema.optional(Rule),
+    list: Schema.optional(Rule),
+    bash: Schema.optional(Rule),
+    task: Schema.optional(Rule),
+    external_directory: Schema.optional(Rule),
+    todowrite: Schema.optional(Action),
+    question: Schema.optional(Action),
+    webfetch: Schema.optional(Action),
+    websearch: Schema.optional(Action),
+    repo_clone: Schema.optional(Rule),
+    repo_overview: Schema.optional(Rule),
+    lsp: Schema.optional(Rule),
+    doom_loop: Schema.optional(Action),
+    skill: Schema.optional(Rule),
+  }),
+  [Schema.Record(Schema.String, Rule)],
+)
+
+// Input the user writes in config: either a single Action (shorthand for "*")
+// or an object of per-target rules.
+const InputSchema = Schema.Union([Action, InputObject])
+
+// Normalise the Action shorthand into `{ "*": action }`. Object inputs pass
+// through untouched.
+const normalizeInput = (input: Schema.Schema.Type<typeof InputSchema>): Schema.Schema.Type<typeof InputObject> =>
+  typeof input === "string" ? { "*": input } : input
+
+export const Info = InputSchema.pipe(
+  Schema.decodeTo(InputObject, {
+    decode: SchemaGetter.transform(normalizeInput),
+    // Not perfectly invertible (we lose whether the user originally typed an
+    // Action shorthand), but the object form is always a valid representation
+    // of the same rules.
+    encode: SchemaGetter.passthrough({ strict: false }),
+  }),
+).annotate({ identifier: "PermissionConfig" })
+type _Info = Schema.Schema.Type<typeof InputObject>
+export type Info = { -readonly [K in keyof _Info]: _Info[K] }