dfcode 1.0.0 → 1.0.1

package/packages/plugin/src/index.ts

@@ -1,226 +0,0 @@
-import type {
-  Event,
-  createDfcodeClient,
-  Project,
-  Model,
-  Provider,
-  Permission,
-  UserMessage,
-  Message,
-  Part,
-  Auth,
-  Config,
-} from "@dfcode/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 createDfcodeClient>
-  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>
-  "tool.execute.after"?: (
-    input: { tool: string; sessionID: string; callID: string },
-    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 },
-    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>
-}

package/packages/plugin/src/shell.ts

@@ -1,136 +0,0 @@
-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

package/packages/plugin/src/tool.ts

@@ -1,28 +0,0 @@
-import { z } from "zod"
-
-export type ToolContext = {
-  sessionID: string
-  messageID: string
-  agent: 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 function tool<Args extends z.ZodRawShape>(input: {
-  description: string
-  args: Args
-  execute(args: z.infer<z.ZodObject<Args>>, context: ToolContext): Promise<string>
-}) {
-  return input
-}
-tool.schema = z
-
-export type ToolDefinition = ReturnType<typeof tool>

package/packages/util/package.json

@@ -1,20 +0,0 @@
-{
-  "name": "@dfcode/util",
-  "version": "1.0.0",
-  "private": true,
-  "type": "module",
-  "license": "MIT",
-  "exports": {
-    "./*": "./src/*.ts"
-  },
-  "scripts": {
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {
-    "zod": "catalog:"
-  },
-  "devDependencies": {
-    "typescript": "catalog:",
-    "@types/bun": "catalog:"
-  }
-}

package/packages/util/src/array.ts

@@ -1,10 +0,0 @@
-export function findLast<T>(
-  items: readonly T[],
-  predicate: (item: T, index: number, items: readonly T[]) => boolean,
-): T | undefined {
-  for (let i = items.length - 1; i >= 0; i -= 1) {
-    const item = items[i]
-    if (predicate(item, i, items)) return item
-  }
-  return undefined
-}

package/packages/util/src/binary.ts

@@ -1,41 +0,0 @@
-export namespace Binary {
-  export function search<T>(array: T[], id: string, compare: (item: T) => string): { found: boolean; index: number } {
-    let left = 0
-    let right = array.length - 1
-
-    while (left <= right) {
-      const mid = Math.floor((left + right) / 2)
-      const midId = compare(array[mid])
-
-      if (midId === id) {
-        return { found: true, index: mid }
-      } else if (midId < id) {
-        left = mid + 1
-      } else {
-        right = mid - 1
-      }
-    }
-
-    return { found: false, index: left }
-  }
-
-  export function insert<T>(array: T[], item: T, compare: (item: T) => string): T[] {
-    const id = compare(item)
-    let left = 0
-    let right = array.length
-
-    while (left < right) {
-      const mid = Math.floor((left + right) / 2)
-      const midId = compare(array[mid])
-
-      if (midId < id) {
-        left = mid + 1
-      } else {
-        right = mid
-      }
-    }
-
-    array.splice(left, 0, item)
-    return array
-  }
-}

package/packages/util/src/encode.ts

@@ -1,30 +0,0 @@
-export function base64Encode(value: string) {
-  const bytes = new TextEncoder().encode(value)
-  const binary = Array.from(bytes, (b) => String.fromCharCode(b)).join("")
-  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "")
-}
-
-export function base64Decode(value: string) {
-  const binary = atob(value.replace(/-/g, "+").replace(/_/g, "/"))
-  const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0))
-  return new TextDecoder().decode(bytes)
-}
-
-export async function hash(content: string, algorithm = "SHA-256"): Promise<string> {
-  const encoder = new TextEncoder()
-  const data = encoder.encode(content)
-  const hashBuffer = await crypto.subtle.digest(algorithm, data)
-  const hashArray = Array.from(new Uint8Array(hashBuffer))
-  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("")
-  return hashHex
-}
-
-export function checksum(content: string): string | undefined {
-  if (!content) return undefined
-  let hash = 0x811c9dc5
-  for (let i = 0; i < content.length; i++) {
-    hash ^= content.charCodeAt(i)
-    hash = Math.imul(hash, 0x01000193)
-  }
-  return (hash >>> 0).toString(36)
-}

package/packages/util/src/error.ts

@@ -1,54 +0,0 @@
-import z from "zod"
-
-export abstract class NamedError extends Error {
-  abstract schema(): z.core.$ZodType
-  abstract toObject(): { name: string; data: any }
-
-  static create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data) {
-    const schema = z
-      .object({
-        name: z.literal(name),
-        data,
-      })
-      .meta({
-        ref: name,
-      })
-    const result = class extends NamedError {
-      public static readonly Schema = schema
-
-      public override readonly name = name as Name
-
-      constructor(
-        public readonly data: z.input<Data>,
-        options?: ErrorOptions,
-      ) {
-        super(name, options)
-        this.name = name
-      }
-
-      static isInstance(input: any): input is InstanceType<typeof result> {
-        return typeof input === "object" && "name" in input && input.name === name
-      }
-
-      schema() {
-        return schema
-      }
-
-      toObject() {
-        return {
-          name: name,
-          data: this.data,
-        }
-      }
-    }
-    Object.defineProperty(result, "name", { value: name })
-    return result
-  }
-
-  public static readonly Unknown = NamedError.create(
-    "UnknownError",
-    z.object({
-      message: z.string(),
-    }),
-  )
-}

package/packages/util/src/fn.ts

@@ -1,11 +0,0 @@
-import { z } from "zod"
-
-export function fn<T extends z.ZodType, Result>(schema: T, cb: (input: z.infer<T>) => Result) {
-  const result = (input: z.infer<T>) => {
-    const parsed = schema.parse(input)
-    return cb(parsed)
-  }
-  result.force = (input: z.infer<T>) => cb(input)
-  result.schema = schema
-  return result
-}

package/packages/util/src/identifier.ts

@@ -1,48 +0,0 @@
-import { randomBytes } from "crypto"
-
-export namespace Identifier {
-  const LENGTH = 26
-
-  // State for monotonic ID generation
-  let lastTimestamp = 0
-  let counter = 0
-
-  export function ascending() {
-    return create(false)
-  }
-
-  export function descending() {
-    return create(true)
-  }
-
-  function randomBase62(length: number): string {
-    const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-    let result = ""
-    const bytes = randomBytes(length)
-    for (let i = 0; i < length; i++) {
-      result += chars[bytes[i] % 62]
-    }
-    return result
-  }
-
-  export function create(descending: boolean, timestamp?: number): string {
-    const currentTimestamp = timestamp ?? Date.now()
-
-    if (currentTimestamp !== lastTimestamp) {
-      lastTimestamp = currentTimestamp
-      counter = 0
-    }
-    counter++
-
-    let now = BigInt(currentTimestamp) * BigInt(0x1000) + BigInt(counter)
-
-    now = descending ? ~now : now
-
-    const timeBytes = Buffer.alloc(6)
-    for (let i = 0; i < 6; i++) {
-      timeBytes[i] = Number((now >> BigInt(40 - 8 * i)) & BigInt(0xff))
-    }
-
-    return timeBytes.toString("hex") + randomBase62(LENGTH - 12)
-  }
-}

package/packages/util/src/iife.ts

@@ -1,3 +0,0 @@
-export function iife<T>(fn: () => T) {
-  return fn()
-}

package/packages/util/src/lazy.ts

@@ -1,11 +0,0 @@
-export function lazy<T>(fn: () => T) {
-  let value: T | undefined
-  let loaded = false
-
-  return (): T => {
-    if (loaded) return value as T
-    loaded = true
-    value = fn()
-    return value as T
-  }
-}

package/packages/util/src/path.ts

@@ -1,37 +0,0 @@
-export function getFilename(path: string | undefined) {
-  if (!path) return ""
-  const trimmed = path.replace(/[\/\\]+$/, "")
-  const parts = trimmed.split(/[\/\\]/)
-  return parts[parts.length - 1] ?? ""
-}
-
-export function getDirectory(path: string | undefined) {
-  if (!path) return ""
-  const trimmed = path.replace(/[\/\\]+$/, "")
-  const parts = trimmed.split(/[\/\\]/)
-  return parts.slice(0, parts.length - 1).join("/") + "/"
-}
-
-export function getFileExtension(path: string | undefined) {
-  if (!path) return ""
-  const parts = path.split(".")
-  return parts[parts.length - 1]
-}
-
-export function getFilenameTruncated(path: string | undefined, maxLength: number = 20) {
-  const filename = getFilename(path)
-  if (filename.length <= maxLength) return filename
-  const lastDot = filename.lastIndexOf(".")
-  const ext = lastDot <= 0 ? "" : filename.slice(lastDot)
-  const available = maxLength - ext.length - 1 // -1 for ellipsis
-  if (available <= 0) return filename.slice(0, maxLength - 1) + "…"
-  return filename.slice(0, available) + "…" + ext
-}
-
-export function truncateMiddle(text: string, maxLength: number = 20) {
-  if (text.length <= maxLength) return text
-  const available = maxLength - 1 // -1 for ellipsis
-  const start = Math.ceil(available / 2)
-  const end = Math.floor(available / 2)
-  return text.slice(0, start) + "…" + text.slice(-end)
-}