mastracode 0.0.1

package/test/config/config.test.ts

@@ -0,0 +1,535 @@
+import { test, expect } from "bun:test"
+import { Config } from "../../src/config/config"
+import { Instance } from "../../src/project/instance"
+import { tmpdir } from "../fixture/fixture"
+import path from "path"
+import fs from "fs/promises"
+import { pathToFileURL } from "url"
+
+test("loads config with defaults when no files exist", async () => {
+  await using tmp = await tmpdir()
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const config = await Config.get()
+      expect(config.username).toBeDefined()
+    },
+  })
+})
+
+test("loads JSON config file", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(
+        path.join(dir, "opencode.json"),
+        JSON.stringify({
+          $schema: "https://opencode.ai/config.json",
+          model: "test/model",
+          username: "testuser",
+        }),
+      )
+    },
+  })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const config = await Config.get()
+      expect(config.model).toBe("test/model")
+      expect(config.username).toBe("testuser")
+    },
+  })
+})
+
+test("loads JSONC config file", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(
+        path.join(dir, "opencode.jsonc"),
+        `{
+        // This is a comment
+        "$schema": "https://opencode.ai/config.json",
+        "model": "test/model",
+        "username": "testuser"
+      }`,
+      )
+    },
+  })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const config = await Config.get()
+      expect(config.model).toBe("test/model")
+      expect(config.username).toBe("testuser")
+    },
+  })
+})
+
+test("merges multiple config files with correct precedence", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(
+        path.join(dir, "opencode.jsonc"),
+        JSON.stringify({
+          $schema: "https://opencode.ai/config.json",
+          model: "base",
+          username: "base",
+        }),
+      )
+      await Bun.write(
+        path.join(dir, "opencode.json"),
+        JSON.stringify({
+          $schema: "https://opencode.ai/config.json",
+          model: "override",
+        }),
+      )
+    },
+  })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const config = await Config.get()
+      expect(config.model).toBe("override")
+      expect(config.username).toBe("base")
+    },
+  })
+})
+
+test("handles environment variable substitution", async () => {
+  const originalEnv = process.env["TEST_VAR"]
+  process.env["TEST_VAR"] = "test_theme"
+
+  try {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(
+          path.join(dir, "opencode.json"),
+          JSON.stringify({
+            $schema: "https://opencode.ai/config.json",
+            theme: "{env:TEST_VAR}",
+          }),
+        )
+      },
+    })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const config = await Config.get()
+        expect(config.theme).toBe("test_theme")
+      },
+    })
+  } finally {
+    if (originalEnv !== undefined) {
+      process.env["TEST_VAR"] = originalEnv
+    } else {
+      delete process.env["TEST_VAR"]
+    }
+  }
+})
+
+test("handles file inclusion substitution", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(path.join(dir, "included.txt"), "test_theme")
+      await Bun.write(
+        path.join(dir, "opencode.json"),
+        JSON.stringify({
+          $schema: "https://opencode.ai/config.json",
+          theme: "{file:included.txt}",
+        }),
+      )
+    },
+  })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const config = await Config.get()
+      expect(config.theme).toBe("test_theme")
+    },
+  })
+})
+
+test("validates config schema and throws on invalid fields", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(
+        path.join(dir, "opencode.json"),
+        JSON.stringify({
+          $schema: "https://opencode.ai/config.json",
+          invalid_field: "should cause error",
+        }),
+      )
+    },
+  })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      // Strict schema should throw an error for invalid fields
+      await expect(Config.get()).rejects.toThrow()
+    },
+  })
+})
+
+test("throws error for invalid JSON", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(path.join(dir, "opencode.json"), "{ invalid json }")
+    },
+  })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      await expect(Config.get()).rejects.toThrow()
+    },
+  })
+})
+
+test("handles agent configuration", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(
+        path.join(dir, "opencode.json"),
+        JSON.stringify({
+          $schema: "https://opencode.ai/config.json",
+          agent: {
+            test_agent: {
+              model: "test/model",
+              temperature: 0.7,
+              description: "test agent",
+            },
+          },
+        }),
+      )
+    },
+  })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const config = await Config.get()
+      expect(config.agent?.["test_agent"]).toEqual({
+        model: "test/model",
+        temperature: 0.7,
+        description: "test agent",
+      })
+    },
+  })
+})
+
+test("handles command configuration", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(
+        path.join(dir, "opencode.json"),
+        JSON.stringify({
+          $schema: "https://opencode.ai/config.json",
+          command: {
+            test_command: {
+              template: "test template",
+              description: "test command",
+              agent: "test_agent",
+            },
+          },
+        }),
+      )
+    },
+  })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const config = await Config.get()
+      expect(config.command?.["test_command"]).toEqual({
+        template: "test template",
+        description: "test command",
+        agent: "test_agent",
+      })
+    },
+  })
+})
+
+test("migrates autoshare to share field", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(
+        path.join(dir, "opencode.json"),
+        JSON.stringify({
+          $schema: "https://opencode.ai/config.json",
+          autoshare: true,
+        }),
+      )
+    },
+  })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const config = await Config.get()
+      expect(config.share).toBe("auto")
+      expect(config.autoshare).toBe(true)
+    },
+  })
+})
+
+test("migrates mode field to agent field", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(
+        path.join(dir, "opencode.json"),
+        JSON.stringify({
+          $schema: "https://opencode.ai/config.json",
+          mode: {
+            test_mode: {
+              model: "test/model",
+              temperature: 0.5,
+            },
+          },
+        }),
+      )
+    },
+  })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const config = await Config.get()
+      expect(config.agent?.["test_mode"]).toEqual({
+        model: "test/model",
+        temperature: 0.5,
+        mode: "primary",
+      })
+    },
+  })
+})
+
+test("loads config from .opencode directory", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      const opencodeDir = path.join(dir, ".opencode")
+      await fs.mkdir(opencodeDir, { recursive: true })
+      const agentDir = path.join(opencodeDir, "agent")
+      await fs.mkdir(agentDir, { recursive: true })
+
+      await Bun.write(
+        path.join(agentDir, "test.md"),
+        `---
+model: test/model
+---
+Test agent prompt`,
+      )
+    },
+  })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const config = await Config.get()
+      expect(config.agent?.["test"]).toEqual({
+        name: "test",
+        model: "test/model",
+        prompt: "Test agent prompt",
+      })
+    },
+  })
+})
+
+test("updates config and writes to file", async () => {
+  await using tmp = await tmpdir()
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const newConfig = { model: "updated/model" }
+      await Config.update(newConfig as any)
+
+      const writtenConfig = JSON.parse(await Bun.file(path.join(tmp.path, "config.json")).text())
+      expect(writtenConfig.model).toBe("updated/model")
+    },
+  })
+})
+
+test("gets config directories", async () => {
+  await using tmp = await tmpdir()
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const dirs = await Config.directories()
+      expect(dirs.length).toBeGreaterThanOrEqual(1)
+    },
+  })
+})
+
+test("resolves scoped npm plugins in config", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      const pluginDir = path.join(dir, "node_modules", "@scope", "plugin")
+      await fs.mkdir(pluginDir, { recursive: true })
+
+      await Bun.write(
+        path.join(dir, "package.json"),
+        JSON.stringify({ name: "config-fixture", version: "1.0.0", type: "module" }, null, 2),
+      )
+
+      await Bun.write(
+        path.join(pluginDir, "package.json"),
+        JSON.stringify(
+          {
+            name: "@scope/plugin",
+            version: "1.0.0",
+            type: "module",
+            main: "./index.js",
+          },
+          null,
+          2,
+        ),
+      )
+
+      await Bun.write(path.join(pluginDir, "index.js"), "export default {}\n")
+
+      await Bun.write(
+        path.join(dir, "opencode.json"),
+        JSON.stringify({ $schema: "https://opencode.ai/config.json", plugin: ["@scope/plugin"] }, null, 2),
+      )
+    },
+  })
+
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const config = await Config.get()
+      const pluginEntries = config.plugin ?? []
+
+      const baseUrl = pathToFileURL(path.join(tmp.path, "opencode.json")).href
+      const expected = import.meta.resolve("@scope/plugin", baseUrl)
+
+      expect(pluginEntries.includes(expected)).toBe(true)
+
+      const scopedEntry = pluginEntries.find((entry) => entry === expected)
+      expect(scopedEntry).toBeDefined()
+      expect(scopedEntry?.includes("/node_modules/@scope/plugin/")).toBe(true)
+    },
+  })
+})
+
+test("merges plugin arrays from global and local configs", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      // Create a nested project structure with local .opencode config
+      const projectDir = path.join(dir, "project")
+      const opencodeDir = path.join(projectDir, ".opencode")
+      await fs.mkdir(opencodeDir, { recursive: true })
+
+      // Global config with plugins
+      await Bun.write(
+        path.join(dir, "opencode.json"),
+        JSON.stringify({
+          $schema: "https://opencode.ai/config.json",
+          plugin: ["global-plugin-1", "global-plugin-2"],
+        }),
+      )
+
+      // Local .opencode config with different plugins
+      await Bun.write(
+        path.join(opencodeDir, "opencode.json"),
+        JSON.stringify({
+          $schema: "https://opencode.ai/config.json",
+          plugin: ["local-plugin-1"],
+        }),
+      )
+    },
+  })
+
+  await Instance.provide({
+    directory: path.join(tmp.path, "project"),
+    fn: async () => {
+      const config = await Config.get()
+      const plugins = config.plugin ?? []
+
+      // Should contain both global and local plugins
+      expect(plugins.some((p) => p.includes("global-plugin-1"))).toBe(true)
+      expect(plugins.some((p) => p.includes("global-plugin-2"))).toBe(true)
+      expect(plugins.some((p) => p.includes("local-plugin-1"))).toBe(true)
+
+      // Should have all 3 plugins (not replaced, but merged)
+      const pluginNames = plugins.filter((p) => p.includes("global-plugin") || p.includes("local-plugin"))
+      expect(pluginNames.length).toBeGreaterThanOrEqual(3)
+    },
+  })
+})
+
+test("does not error when only custom agent is a subagent", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      const opencodeDir = path.join(dir, ".opencode")
+      await fs.mkdir(opencodeDir, { recursive: true })
+      const agentDir = path.join(opencodeDir, "agent")
+      await fs.mkdir(agentDir, { recursive: true })
+
+      await Bun.write(
+        path.join(agentDir, "helper.md"),
+        `---
+model: test/model
+mode: subagent
+---
+Helper subagent prompt`,
+      )
+    },
+  })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const config = await Config.get()
+      expect(config.agent?.["helper"]).toEqual({
+        name: "helper",
+        model: "test/model",
+        mode: "subagent",
+        prompt: "Helper subagent prompt",
+      })
+    },
+  })
+})
+
+test("deduplicates duplicate plugins from global and local configs", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      // Create a nested project structure with local .opencode config
+      const projectDir = path.join(dir, "project")
+      const opencodeDir = path.join(projectDir, ".opencode")
+      await fs.mkdir(opencodeDir, { recursive: true })
+
+      // Global config with plugins
+      await Bun.write(
+        path.join(dir, "opencode.json"),
+        JSON.stringify({
+          $schema: "https://opencode.ai/config.json",
+          plugin: ["duplicate-plugin", "global-plugin-1"],
+        }),
+      )
+
+      // Local .opencode config with some overlapping plugins
+      await Bun.write(
+        path.join(opencodeDir, "opencode.json"),
+        JSON.stringify({
+          $schema: "https://opencode.ai/config.json",
+          plugin: ["duplicate-plugin", "local-plugin-1"],
+        }),
+      )
+    },
+  })
+
+  await Instance.provide({
+    directory: path.join(tmp.path, "project"),
+    fn: async () => {
+      const config = await Config.get()
+      const plugins = config.plugin ?? []
+
+      // Should contain all unique plugins
+      expect(plugins.some((p) => p.includes("global-plugin-1"))).toBe(true)
+      expect(plugins.some((p) => p.includes("local-plugin-1"))).toBe(true)
+      expect(plugins.some((p) => p.includes("duplicate-plugin"))).toBe(true)
+
+      // Should deduplicate the duplicate plugin
+      const duplicatePlugins = plugins.filter((p) => p.includes("duplicate-plugin"))
+      expect(duplicatePlugins.length).toBe(1)
+
+      // Should have exactly 3 unique plugins
+      const pluginNames = plugins.filter(
+        (p) => p.includes("global-plugin") || p.includes("local-plugin") || p.includes("duplicate-plugin"),
+      )
+      expect(pluginNames.length).toBe(3)
+    },
+  })
+})

package/test/config/markdown.test.ts

@@ -0,0 +1,89 @@
+import { expect, test } from "bun:test"
+import { ConfigMarkdown } from "../../src/config/markdown"
+
+const template = `This is a @valid/path/to/a/file and it should also match at
+the beginning of a line:
+
+@another-valid/path/to/a/file
+
+but this is not:
+
+   - Adds a "Co-authored-by:" footer which clarifies which AI agent
+     helped create this commit, using an appropriate \`noreply@...\`
+     or \`noreply@anthropic.com\` email address.
+
+We also need to deal with files followed by @commas, ones
+with @file-extensions.md, even @multiple.extensions.bak,
+hidden directorys like @.config/ or files like @.bashrc
+and ones at the end of a sentence like @foo.md.
+
+Also shouldn't forget @/absolute/paths.txt with and @/without/extensions,
+as well as @~/home-files and @~/paths/under/home.txt.
+
+If the reference is \`@quoted/in/backticks\` then it shouldn't match at all.`
+
+const matches = ConfigMarkdown.files(template)
+
+test("should extract exactly 12 file references", () => {
+  expect(matches.length).toBe(12)
+})
+
+test("should extract valid/path/to/a/file", () => {
+  expect(matches[0][1]).toBe("valid/path/to/a/file")
+})
+
+test("should extract another-valid/path/to/a/file", () => {
+  expect(matches[1][1]).toBe("another-valid/path/to/a/file")
+})
+
+test("should extract paths ignoring comma after", () => {
+  expect(matches[2][1]).toBe("commas")
+})
+
+test("should extract a path with a file extension and comma after", () => {
+  expect(matches[3][1]).toBe("file-extensions.md")
+})
+
+test("should extract a path with multiple dots and comma after", () => {
+  expect(matches[4][1]).toBe("multiple.extensions.bak")
+})
+
+test("should extract hidden directory", () => {
+  expect(matches[5][1]).toBe(".config/")
+})
+
+test("should extract hidden file", () => {
+  expect(matches[6][1]).toBe(".bashrc")
+})
+
+test("should extract a file ignoring period at end of sentence", () => {
+  expect(matches[7][1]).toBe("foo.md")
+})
+
+test("should extract an absolute path with an extension", () => {
+  expect(matches[8][1]).toBe("/absolute/paths.txt")
+})
+
+test("should extract an absolute path without an extension", () => {
+  expect(matches[9][1]).toBe("/without/extensions")
+})
+
+test("should extract an absolute path in home directory", () => {
+  expect(matches[10][1]).toBe("~/home-files")
+})
+
+test("should extract an absolute path under home directory", () => {
+  expect(matches[11][1]).toBe("~/paths/under/home.txt")
+})
+
+test("should not match when preceded by backtick", () => {
+  const backtickTest = "This `@should/not/match` should be ignored"
+  const backtickMatches = ConfigMarkdown.files(backtickTest)
+  expect(backtickMatches.length).toBe(0)
+})
+
+test("should not match email addresses", () => {
+  const emailTest = "Contact user@example.com for help"
+  const emailMatches = ConfigMarkdown.files(emailTest)
+  expect(emailMatches.length).toBe(0)
+})

package/test/file/ignore.test.ts

@@ -0,0 +1,10 @@
+import { test, expect } from "bun:test"
+import { FileIgnore } from "../../src/file/ignore"
+
+test("match nested and non-nested", () => {
+  expect(FileIgnore.match("node_modules/index.js")).toBe(true)
+  expect(FileIgnore.match("node_modules")).toBe(true)
+  expect(FileIgnore.match("node_modules/")).toBe(true)
+  expect(FileIgnore.match("node_modules/bar")).toBe(true)
+  expect(FileIgnore.match("node_modules/bar/")).toBe(true)
+})

package/test/fixture/fixture.ts

@@ -0,0 +1,34 @@
+import { $ } from "bun"
+import * as fs from "fs/promises"
+import os from "os"
+import path from "path"
+
+// Strip null bytes from paths (defensive fix for CI environment issues)
+function sanitizePath(p: string): string {
+  return p.replace(/\0/g, "")
+}
+
+type TmpDirOptions<T> = {
+  git?: boolean
+  init?: (dir: string) => Promise<T>
+  dispose?: (dir: string) => Promise<T>
+}
+export async function tmpdir<T>(options?: TmpDirOptions<T>) {
+  const dirpath = sanitizePath(path.join(os.tmpdir(), "opencode-test-" + Math.random().toString(36).slice(2)))
+  await fs.mkdir(dirpath, { recursive: true })
+  if (options?.git) {
+    await $`git init`.cwd(dirpath).quiet()
+    await $`git commit --allow-empty -m "root commit ${dirpath}"`.cwd(dirpath).quiet()
+  }
+  const extra = await options?.init?.(dirpath)
+  const realpath = sanitizePath(await fs.realpath(dirpath))
+  const result = {
+    [Symbol.asyncDispose]: async () => {
+      await options?.dispose?.(dirpath)
+      // await fs.rm(dirpath, { recursive: true, force: true })
+    },
+    path: realpath,
+    extra: extra as T,
+  }
+  return result
+}