chad-code 1.3.1 → 1.3.2

package/src/worktree/index.ts

@@ -1,217 +0,0 @@
-import { $ } from "bun"
-import fs from "fs/promises"
-import path from "path"
-import z from "zod"
-import { NamedError } from "@opencode-ai/util/error"
-import { Global } from "../global"
-import { Instance } from "../project/instance"
-import { Project } from "../project/project"
-import { fn } from "../util/fn"
-import { Config } from "@/config/config"
-
-export namespace Worktree {
-  export const Info = z
-    .object({
-      name: z.string(),
-      branch: z.string(),
-      directory: z.string(),
-    })
-    .meta({
-      ref: "Worktree",
-    })
-
-  export type Info = z.infer<typeof Info>
-
-  export const CreateInput = z
-    .object({
-      name: z.string().optional(),
-      startCommand: z.string().optional(),
-    })
-    .meta({
-      ref: "WorktreeCreateInput",
-    })
-
-  export type CreateInput = z.infer<typeof CreateInput>
-
-  export const NotGitError = NamedError.create(
-    "WorktreeNotGitError",
-    z.object({
-      message: z.string(),
-    }),
-  )
-
-  export const NameGenerationFailedError = NamedError.create(
-    "WorktreeNameGenerationFailedError",
-    z.object({
-      message: z.string(),
-    }),
-  )
-
-  export const CreateFailedError = NamedError.create(
-    "WorktreeCreateFailedError",
-    z.object({
-      message: z.string(),
-    }),
-  )
-
-  export const StartCommandFailedError = NamedError.create(
-    "WorktreeStartCommandFailedError",
-    z.object({
-      message: z.string(),
-    }),
-  )
-
-  const ADJECTIVES = [
-    "brave",
-    "calm",
-    "clever",
-    "cosmic",
-    "crisp",
-    "curious",
-    "eager",
-    "gentle",
-    "glowing",
-    "happy",
-    "hidden",
-    "jolly",
-    "kind",
-    "lucky",
-    "mighty",
-    "misty",
-    "neon",
-    "nimble",
-    "playful",
-    "proud",
-    "quick",
-    "quiet",
-    "shiny",
-    "silent",
-    "stellar",
-    "sunny",
-    "swift",
-    "tidy",
-    "witty",
-  ] as const
-
-  const NOUNS = [
-    "cabin",
-    "cactus",
-    "canyon",
-    "circuit",
-    "comet",
-    "eagle",
-    "engine",
-    "falcon",
-    "forest",
-    "garden",
-    "harbor",
-    "island",
-    "knight",
-    "lagoon",
-    "meadow",
-    "moon",
-    "mountain",
-    "nebula",
-    "orchid",
-    "otter",
-    "panda",
-    "pixel",
-    "planet",
-    "river",
-    "rocket",
-    "sailor",
-    "squid",
-    "star",
-    "tiger",
-    "wizard",
-    "wolf",
-  ] as const
-
-  function pick<const T extends readonly string[]>(list: T) {
-    return list[Math.floor(Math.random() * list.length)]
-  }
-
-  function slug(input: string) {
-    return input
-      .trim()
-      .toLowerCase()
-      .replace(/[^a-z0-9]+/g, "-")
-      .replace(/^-+/, "")
-      .replace(/-+$/, "")
-  }
-
-  function randomName() {
-    return `${pick(ADJECTIVES)}-${pick(NOUNS)}`
-  }
-
-  async function exists(target: string) {
-    return fs
-      .stat(target)
-      .then(() => true)
-      .catch(() => false)
-  }
-
-  function outputText(input: Uint8Array | undefined) {
-    if (!input?.length) return ""
-    return new TextDecoder().decode(input).trim()
-  }
-
-  function errorText(result: { stdout?: Uint8Array; stderr?: Uint8Array }) {
-    return [outputText(result.stderr), outputText(result.stdout)].filter(Boolean).join("\n")
-  }
-
-  async function candidate(root: string, base?: string) {
-    for (const attempt of Array.from({ length: 26 }, (_, i) => i)) {
-      const name = base ? (attempt === 0 ? base : `${base}-${randomName()}`) : randomName()
-      const branch = `chad-code/${name}`
-      const directory = path.join(root, name)
-
-      if (await exists(directory)) continue
-
-      const ref = `refs/heads/${branch}`
-      const branchCheck = await $`git show-ref --verify --quiet ${ref}`.quiet().nothrow().cwd(Instance.worktree)
-      if (branchCheck.exitCode === 0) continue
-
-      return Info.parse({ name, branch, directory })
-    }
-
-    throw new NameGenerationFailedError({ message: "Failed to generate a unique worktree name" })
-  }
-
-  async function runStartCommand(directory: string, cmd: string) {
-    if (process.platform === "win32") {
-      return $`cmd /c ${cmd}`.nothrow().cwd(directory)
-    }
-    return $`bash -lc ${cmd}`.nothrow().cwd(directory)
-  }
-
-  export const create = fn(CreateInput.optional(), async (input) => {
-    if (Instance.project.vcs !== "git") {
-      throw new NotGitError({ message: "Worktrees are only supported for git projects" })
-    }
-
-    const root = path.join(Global.Path.data, "worktree", Instance.project.id)
-    await fs.mkdir(root, { recursive: true })
-
-    const base = input?.name ? slug(input.name) : ""
-    const info = await candidate(root, base || undefined)
-
-    const created = await $`git worktree add -b ${info.branch} ${info.directory}`
-      .quiet()
-      .nothrow()
-      .cwd(Instance.worktree)
-    if (created.exitCode !== 0) {
-      throw new CreateFailedError({ message: errorText(created) || "Failed to create git worktree" })
-    }
-
-    const cmd = input?.startCommand?.trim()
-    if (!cmd) return info
-
-    const ran = await runStartCommand(info.directory, cmd)
-    if (ran.exitCode !== 0) {
-      throw new StartCommandFailedError({ message: errorText(ran) || "Worktree start command failed" })
-    }
-
-    return info
-  })
-}

package/sst-env.d.ts

@@ -1,9 +0,0 @@
-/* This file is auto-generated by SST. Do not edit. */
-/* tslint:disable */
-/* eslint-disable */
-/* deno-fmt-ignore-file */
-
-/// <reference path="../../sst-env.d.ts" />
-
-import "sst"
-export {}

package/test/agent/agent.test.ts

@@ -1,448 +0,0 @@
-import { test, expect } from "bun:test"
-import { tmpdir } from "../fixture/fixture"
-import { Instance } from "../../src/project/instance"
-import { Agent } from "../../src/agent/agent"
-import { PermissionNext } from "../../src/permission/next"
-
-// Helper to evaluate permission for a tool with wildcard pattern
-function evalPerm(agent: Agent.Info | undefined, permission: string): PermissionNext.Action | undefined {
-  if (!agent) return undefined
-  return PermissionNext.evaluate(permission, "*", agent.permission).action
-}
-
-test("returns default native agents when no config", async () => {
-  await using tmp = await tmpdir()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const agents = await Agent.list()
-      const names = agents.map((a) => a.name)
-      expect(names).toContain("build")
-      expect(names).toContain("plan")
-      expect(names).toContain("general")
-      expect(names).toContain("explore")
-      expect(names).toContain("compaction")
-      expect(names).toContain("title")
-      expect(names).toContain("summary")
-    },
-  })
-})
-
-test("build agent has correct default properties", async () => {
-  await using tmp = await tmpdir()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const build = await Agent.get("build")
-      expect(build).toBeDefined()
-      expect(build?.mode).toBe("primary")
-      expect(build?.native).toBe(true)
-      expect(evalPerm(build, "edit")).toBe("allow")
-      expect(evalPerm(build, "bash")).toBe("allow")
-    },
-  })
-})
-
-test("plan agent denies edits except .opencode/plan/*", async () => {
-  await using tmp = await tmpdir()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const plan = await Agent.get("plan")
-      expect(plan).toBeDefined()
-      // Wildcard is denied
-      expect(evalPerm(plan, "edit")).toBe("deny")
-      // But specific path is allowed
-      expect(PermissionNext.evaluate("edit", ".opencode/plan/foo.md", plan!.permission).action).toBe("allow")
-    },
-  })
-})
-
-test("explore agent denies edit and write", async () => {
-  await using tmp = await tmpdir()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const explore = await Agent.get("explore")
-      expect(explore).toBeDefined()
-      expect(explore?.mode).toBe("subagent")
-      expect(evalPerm(explore, "edit")).toBe("deny")
-      expect(evalPerm(explore, "write")).toBe("deny")
-      expect(evalPerm(explore, "todoread")).toBe("deny")
-      expect(evalPerm(explore, "todowrite")).toBe("deny")
-    },
-  })
-})
-
-test("general agent denies todo tools", async () => {
-  await using tmp = await tmpdir()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const general = await Agent.get("general")
-      expect(general).toBeDefined()
-      expect(general?.mode).toBe("subagent")
-      expect(general?.hidden).toBe(true)
-      expect(evalPerm(general, "todoread")).toBe("deny")
-      expect(evalPerm(general, "todowrite")).toBe("deny")
-    },
-  })
-})
-
-test("compaction agent denies all permissions", async () => {
-  await using tmp = await tmpdir()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const compaction = await Agent.get("compaction")
-      expect(compaction).toBeDefined()
-      expect(compaction?.hidden).toBe(true)
-      expect(evalPerm(compaction, "bash")).toBe("deny")
-      expect(evalPerm(compaction, "edit")).toBe("deny")
-      expect(evalPerm(compaction, "read")).toBe("deny")
-    },
-  })
-})
-
-test("custom agent from config creates new agent", async () => {
-  await using tmp = await tmpdir({
-    config: {
-      agent: {
-        my_custom_agent: {
-          model: "openai/gpt-4",
-          description: "My custom agent",
-          temperature: 0.5,
-          top_p: 0.9,
-        },
-      },
-    },
-  })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const custom = await Agent.get("my_custom_agent")
-      expect(custom).toBeDefined()
-      expect(custom?.model?.providerID).toBe("openai")
-      expect(custom?.model?.modelID).toBe("gpt-4")
-      expect(custom?.description).toBe("My custom agent")
-      expect(custom?.temperature).toBe(0.5)
-      expect(custom?.topP).toBe(0.9)
-      expect(custom?.native).toBe(false)
-      expect(custom?.mode).toBe("all")
-    },
-  })
-})
-
-test("custom agent config overrides native agent properties", async () => {
-  await using tmp = await tmpdir({
-    config: {
-      agent: {
-        build: {
-          model: "anthropic/claude-3",
-          description: "Custom build agent",
-          temperature: 0.7,
-          color: "#FF0000",
-        },
-      },
-    },
-  })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const build = await Agent.get("build")
-      expect(build).toBeDefined()
-      expect(build?.model?.providerID).toBe("anthropic")
-      expect(build?.model?.modelID).toBe("claude-3")
-      expect(build?.description).toBe("Custom build agent")
-      expect(build?.temperature).toBe(0.7)
-      expect(build?.color).toBe("#FF0000")
-      expect(build?.native).toBe(true)
-    },
-  })
-})
-
-test("agent disable removes agent from list", async () => {
-  await using tmp = await tmpdir({
-    config: {
-      agent: {
-        explore: { disable: true },
-      },
-    },
-  })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const explore = await Agent.get("explore")
-      expect(explore).toBeUndefined()
-      const agents = await Agent.list()
-      const names = agents.map((a) => a.name)
-      expect(names).not.toContain("explore")
-    },
-  })
-})
-
-test("agent permission config merges with defaults", async () => {
-  await using tmp = await tmpdir({
-    config: {
-      agent: {
-        build: {
-          permission: {
-            bash: {
-              "rm -rf *": "deny",
-            },
-          },
-        },
-      },
-    },
-  })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const build = await Agent.get("build")
-      expect(build).toBeDefined()
-      // Specific pattern is denied
-      expect(PermissionNext.evaluate("bash", "rm -rf *", build!.permission).action).toBe("deny")
-      // Edit still allowed
-      expect(evalPerm(build, "edit")).toBe("allow")
-    },
-  })
-})
-
-test("global permission config applies to all agents", async () => {
-  await using tmp = await tmpdir({
-    config: {
-      permission: {
-        bash: "deny",
-      },
-    },
-  })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const build = await Agent.get("build")
-      expect(build).toBeDefined()
-      expect(evalPerm(build, "bash")).toBe("deny")
-    },
-  })
-})
-
-test("agent steps/maxSteps config sets steps property", async () => {
-  await using tmp = await tmpdir({
-    config: {
-      agent: {
-        build: { steps: 50 },
-        plan: { maxSteps: 100 },
-      },
-    },
-  })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const build = await Agent.get("build")
-      const plan = await Agent.get("plan")
-      expect(build?.steps).toBe(50)
-      expect(plan?.steps).toBe(100)
-    },
-  })
-})
-
-test("agent mode can be overridden", async () => {
-  await using tmp = await tmpdir({
-    config: {
-      agent: {
-        explore: { mode: "primary" },
-      },
-    },
-  })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const explore = await Agent.get("explore")
-      expect(explore?.mode).toBe("primary")
-    },
-  })
-})
-
-test("agent name can be overridden", async () => {
-  await using tmp = await tmpdir({
-    config: {
-      agent: {
-        build: { name: "Builder" },
-      },
-    },
-  })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const build = await Agent.get("build")
-      expect(build?.name).toBe("Builder")
-    },
-  })
-})
-
-test("agent prompt can be set from config", async () => {
-  await using tmp = await tmpdir({
-    config: {
-      agent: {
-        build: { prompt: "Custom system prompt" },
-      },
-    },
-  })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const build = await Agent.get("build")
-      expect(build?.prompt).toBe("Custom system prompt")
-    },
-  })
-})
-
-test("unknown agent properties are placed into options", async () => {
-  await using tmp = await tmpdir({
-    config: {
-      agent: {
-        build: {
-          random_property: "hello",
-          another_random: 123,
-        },
-      },
-    },
-  })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const build = await Agent.get("build")
-      expect(build?.options.random_property).toBe("hello")
-      expect(build?.options.another_random).toBe(123)
-    },
-  })
-})
-
-test("agent options merge correctly", async () => {
-  await using tmp = await tmpdir({
-    config: {
-      agent: {
-        build: {
-          options: {
-            custom_option: true,
-            another_option: "value",
-          },
-        },
-      },
-    },
-  })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const build = await Agent.get("build")
-      expect(build?.options.custom_option).toBe(true)
-      expect(build?.options.another_option).toBe("value")
-    },
-  })
-})
-
-test("multiple custom agents can be defined", async () => {
-  await using tmp = await tmpdir({
-    config: {
-      agent: {
-        agent_a: {
-          description: "Agent A",
-          mode: "subagent",
-        },
-        agent_b: {
-          description: "Agent B",
-          mode: "primary",
-        },
-      },
-    },
-  })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const agentA = await Agent.get("agent_a")
-      const agentB = await Agent.get("agent_b")
-      expect(agentA?.description).toBe("Agent A")
-      expect(agentA?.mode).toBe("subagent")
-      expect(agentB?.description).toBe("Agent B")
-      expect(agentB?.mode).toBe("primary")
-    },
-  })
-})
-
-test("Agent.get returns undefined for non-existent agent", async () => {
-  await using tmp = await tmpdir()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const nonExistent = await Agent.get("does_not_exist")
-      expect(nonExistent).toBeUndefined()
-    },
-  })
-})
-
-test("default permission includes doom_loop and external_directory as ask", async () => {
-  await using tmp = await tmpdir()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const build = await Agent.get("build")
-      expect(evalPerm(build, "doom_loop")).toBe("ask")
-      expect(evalPerm(build, "external_directory")).toBe("ask")
-    },
-  })
-})
-
-test("webfetch is allowed by default", async () => {
-  await using tmp = await tmpdir()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const build = await Agent.get("build")
-      expect(evalPerm(build, "webfetch")).toBe("allow")
-    },
-  })
-})
-
-test("legacy tools config converts to permissions", async () => {
-  await using tmp = await tmpdir({
-    config: {
-      agent: {
-        build: {
-          tools: {
-            bash: false,
-            read: false,
-          },
-        },
-      },
-    },
-  })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const build = await Agent.get("build")
-      expect(evalPerm(build, "bash")).toBe("deny")
-      expect(evalPerm(build, "read")).toBe("deny")
-    },
-  })
-})
-
-test("legacy tools config maps write/edit/patch/multiedit to edit permission", async () => {
-  await using tmp = await tmpdir({
-    config: {
-      agent: {
-        build: {
-          tools: {
-            write: false,
-          },
-        },
-      },
-    },
-  })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const build = await Agent.get("build")
-      expect(evalPerm(build, "edit")).toBe("deny")
-    },
-  })
-})