rird 1.0.200

package/src/tests/agent.test.ts

@@ -0,0 +1,308 @@
+import { describe, test, expect } from "bun:test"
+import z from "zod"
+import { Agent } from "../agent/agent"
+
+describe("Agent.Info schema", () => {
+  test("agent info schema has required fields", () => {
+    const shape = Agent.Info.shape
+
+    // Required fields
+    expect(shape.name).toBeDefined()
+    expect(shape.mode).toBeDefined()
+    expect(shape.permission).toBeDefined()
+    expect(shape.tools).toBeDefined()
+    expect(shape.options).toBeDefined()
+  })
+
+  test("agent mode enum has correct values", () => {
+    // Test that valid modes are accepted
+    const validModes = ["subagent", "primary", "all"]
+
+    for (const mode of validModes) {
+      const testAgent = {
+        name: "test",
+        mode,
+        permission: { edit: "allow", bash: { "*": "allow" }, skill: { "*": "allow" } },
+        tools: {},
+        options: {},
+      }
+      const result = Agent.Info.safeParse(testAgent)
+      expect(result.success).toBe(true)
+    }
+
+    // Test that invalid mode is rejected
+    const invalidAgent = {
+      name: "test",
+      mode: "invalid",
+      permission: { edit: "allow", bash: { "*": "allow" }, skill: { "*": "allow" } },
+      tools: {},
+      options: {},
+    }
+    const result = Agent.Info.safeParse(invalidAgent)
+    expect(result.success).toBe(false)
+  })
+
+  test("agent permission structure is valid", () => {
+    const permissionSchema = Agent.Info.shape.permission
+    const permissionShape = (permissionSchema as z.ZodObject<any>).shape
+
+    expect(permissionShape.edit).toBeDefined()
+    expect(permissionShape.bash).toBeDefined()
+    expect(permissionShape.skill).toBeDefined()
+    expect(permissionShape.webfetch).toBeDefined()
+    expect(permissionShape.doom_loop).toBeDefined()
+    expect(permissionShape.external_directory).toBeDefined()
+  })
+
+  test("agent info validates correctly for valid data", () => {
+    const validAgent: z.input<typeof Agent.Info> = {
+      name: "test-agent",
+      mode: "primary",
+      permission: {
+        edit: "allow",
+        bash: { "*": "allow" },
+        skill: { "*": "allow" },
+      },
+      tools: {},
+      options: {},
+    }
+
+    const result = Agent.Info.safeParse(validAgent)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.name).toBe("test-agent")
+      expect(result.data.mode).toBe("primary")
+    }
+  })
+
+  test("agent info rejects invalid mode", () => {
+    const invalidAgent = {
+      name: "test-agent",
+      mode: "invalid-mode",
+      permission: {
+        edit: "allow",
+        bash: { "*": "allow" },
+        skill: { "*": "allow" },
+      },
+      tools: {},
+      options: {},
+    }
+
+    const result = Agent.Info.safeParse(invalidAgent)
+    expect(result.success).toBe(false)
+  })
+
+  test("optional fields are optional", () => {
+    const minimalAgent: z.input<typeof Agent.Info> = {
+      name: "minimal",
+      mode: "subagent",
+      permission: {
+        edit: "deny",
+        bash: { "*": "deny" },
+        skill: { "*": "deny" },
+      },
+      tools: {},
+      options: {},
+    }
+
+    const result = Agent.Info.safeParse(minimalAgent)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.description).toBeUndefined()
+      expect(result.data.native).toBeUndefined()
+      expect(result.data.hidden).toBeUndefined()
+      expect(result.data.default).toBeUndefined()
+      expect(result.data.topP).toBeUndefined()
+      expect(result.data.temperature).toBeUndefined()
+      expect(result.data.color).toBeUndefined()
+      expect(result.data.model).toBeUndefined()
+      expect(result.data.prompt).toBeUndefined()
+      expect(result.data.maxSteps).toBeUndefined()
+    }
+  })
+
+  test("agent with all optional fields validates", () => {
+    const fullAgent: z.input<typeof Agent.Info> = {
+      name: "full-agent",
+      description: "A test agent",
+      mode: "all",
+      native: true,
+      hidden: false,
+      default: true,
+      topP: 0.9,
+      temperature: 0.7,
+      color: "#FF5733",
+      permission: {
+        edit: "ask",
+        bash: { "*": "ask", "echo *": "allow" },
+        skill: { "*": "allow" },
+        webfetch: "allow",
+        doom_loop: "ask",
+        external_directory: "deny",
+      },
+      model: {
+        modelID: "claude-3-opus",
+        providerID: "anthropic",
+      },
+      prompt: "You are a helpful assistant",
+      tools: { bash: true, read: true },
+      options: { customOption: "value" },
+      maxSteps: 100,
+    }
+
+    const result = Agent.Info.safeParse(fullAgent)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.description).toBe("A test agent")
+      expect(result.data.temperature).toBe(0.7)
+      expect(result.data.topP).toBe(0.9)
+      expect(result.data.maxSteps).toBe(100)
+    }
+  })
+
+  test("permission values are valid enum values", () => {
+    const validPermissions = ["ask", "allow", "deny"]
+
+    const testAgent: z.input<typeof Agent.Info> = {
+      name: "perm-test",
+      mode: "primary",
+      permission: {
+        edit: "ask",
+        bash: { "*": "allow" },
+        skill: { "*": "deny" },
+        webfetch: "allow",
+        doom_loop: "ask",
+        external_directory: "deny",
+      },
+      tools: {},
+      options: {},
+    }
+
+    const result = Agent.Info.safeParse(testAgent)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(validPermissions).toContain(result.data.permission.edit)
+      expect(validPermissions).toContain(result.data.permission.webfetch as string)
+    }
+  })
+
+  test("maxSteps must be positive integer", () => {
+    const negativeSteps = {
+      name: "test",
+      mode: "primary",
+      permission: { edit: "allow", bash: { "*": "allow" }, skill: { "*": "allow" } },
+      tools: {},
+      options: {},
+      maxSteps: -1,
+    }
+
+    const result = Agent.Info.safeParse(negativeSteps)
+    expect(result.success).toBe(false)
+  })
+
+  test("temperature can be decimal number", () => {
+    const agent: z.input<typeof Agent.Info> = {
+      name: "temp-test",
+      mode: "primary",
+      permission: { edit: "allow", bash: { "*": "allow" }, skill: { "*": "allow" } },
+      tools: {},
+      options: {},
+      temperature: 0.5,
+    }
+
+    const result = Agent.Info.safeParse(agent)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.temperature).toBe(0.5)
+    }
+  })
+})
+
+describe("Agent mode definitions", () => {
+  test("subagent mode is valid", () => {
+    const agent: z.input<typeof Agent.Info> = {
+      name: "subagent-test",
+      mode: "subagent",
+      permission: { edit: "deny", bash: { "*": "deny" }, skill: { "*": "deny" } },
+      tools: {},
+      options: {},
+    }
+
+    const result = Agent.Info.safeParse(agent)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.mode).toBe("subagent")
+    }
+  })
+
+  test("primary mode is valid", () => {
+    const agent: z.input<typeof Agent.Info> = {
+      name: "primary-test",
+      mode: "primary",
+      permission: { edit: "allow", bash: { "*": "allow" }, skill: { "*": "allow" } },
+      tools: {},
+      options: {},
+    }
+
+    const result = Agent.Info.safeParse(agent)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.mode).toBe("primary")
+    }
+  })
+
+  test("all mode is valid", () => {
+    const agent: z.input<typeof Agent.Info> = {
+      name: "all-test",
+      mode: "all",
+      permission: { edit: "ask", bash: { "*": "ask" }, skill: { "*": "ask" } },
+      tools: {},
+      options: {},
+    }
+
+    const result = Agent.Info.safeParse(agent)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.mode).toBe("all")
+    }
+  })
+})
+
+describe("Agent model configuration", () => {
+  test("model requires both modelID and providerID", () => {
+    const agentWithModel: z.input<typeof Agent.Info> = {
+      name: "model-test",
+      mode: "primary",
+      permission: { edit: "allow", bash: { "*": "allow" }, skill: { "*": "allow" } },
+      tools: {},
+      options: {},
+      model: {
+        modelID: "gpt-4",
+        providerID: "openai",
+      },
+    }
+
+    const result = Agent.Info.safeParse(agentWithModel)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.model?.modelID).toBe("gpt-4")
+      expect(result.data.model?.providerID).toBe("openai")
+    }
+  })
+
+  test("model with missing providerID fails", () => {
+    const agentInvalidModel = {
+      name: "model-test",
+      mode: "primary",
+      permission: { edit: "allow", bash: { "*": "allow" }, skill: { "*": "allow" } },
+      tools: {},
+      options: {},
+      model: {
+        modelID: "gpt-4",
+      },
+    }
+
+    const result = Agent.Info.safeParse(agentInvalidModel)
+    expect(result.success).toBe(false)
+  })
+})

package/src/tests/build-guards.test.ts

@@ -0,0 +1,267 @@
+/**
+ * Tier 1 Build & Syntax Guards
+ *
+ * These tests run on every PR to catch build/syntax issues early.
+ * They verify:
+ * 1. TypeScript compiles without errors (imports resolve)
+ * 2. No circular import issues in key modules
+ * 3. Agent modes are properly defined
+ * 4. Tool definitions have required fields
+ * 5. Prompt template files exist and are non-empty
+ *
+ * Run with: bun test build-guards.test.ts
+ */
+
+import { describe, it, expect, test } from "bun:test"
+import * as fs from "fs"
+import * as path from "path"
+
+// ------------------------------------------------------------------
+// 1. TypeScript Compilation - Verify key imports resolve
+// ------------------------------------------------------------------
+describe("TypeScript Compilation", () => {
+  it("should import Tool namespace without errors", async () => {
+    const { Tool } = await import("../tool/tool")
+    expect(Tool).toBeDefined()
+    expect(Tool.define).toBeInstanceOf(Function)
+  })
+
+  it("should import Agent namespace without errors", async () => {
+    const { Agent } = await import("../agent/agent")
+    expect(Agent).toBeDefined()
+    expect(Agent.Info).toBeDefined()
+  })
+
+  it("should import ToolRegistry without errors", async () => {
+    const { ToolRegistry } = await import("../tool/registry")
+    expect(ToolRegistry).toBeDefined()
+    expect(ToolRegistry.register).toBeInstanceOf(Function)
+  })
+
+  it("should import Config namespace without errors", async () => {
+    const { Config } = await import("../config/config")
+    expect(Config).toBeDefined()
+  })
+
+  it("should import Provider namespace without errors", async () => {
+    const { Provider } = await import("../provider/provider")
+    expect(Provider).toBeDefined()
+  })
+})
+
+// ------------------------------------------------------------------
+// 2. Circular Import Detection - Import key modules together
+// ------------------------------------------------------------------
+describe("Circular Import Detection", () => {
+  it("should import tool and agent modules without circular dependency errors", async () => {
+    // Import order matters for circular deps - test common patterns
+    const [toolModule, agentModule] = await Promise.all([
+      import("../tool/tool"),
+      import("../agent/agent"),
+    ])
+    expect(toolModule.Tool).toBeDefined()
+    expect(agentModule.Agent).toBeDefined()
+  })
+
+  it("should import registry with all tools without circular dependency errors", async () => {
+    const { ToolRegistry } = await import("../tool/registry")
+    const { BashTool } = await import("../tool/bash")
+    const { ReadTool } = await import("../tool/read")
+    const { EditTool } = await import("../tool/edit")
+    const { WriteTool } = await import("../tool/write")
+    const { GlobTool } = await import("../tool/glob")
+    const { GrepTool } = await import("../tool/grep")
+
+    expect(ToolRegistry).toBeDefined()
+    expect(BashTool).toBeDefined()
+    expect(ReadTool).toBeDefined()
+    expect(EditTool).toBeDefined()
+    expect(WriteTool).toBeDefined()
+    expect(GlobTool).toBeDefined()
+    expect(GrepTool).toBeDefined()
+  })
+
+  it("should import session and provider modules together", async () => {
+    const [sessionModule, providerModule] = await Promise.all([
+      import("../session"),
+      import("../provider/provider"),
+    ])
+    expect(sessionModule.Session).toBeDefined()
+    expect(providerModule.Provider).toBeDefined()
+  })
+})
+
+// ------------------------------------------------------------------
+// 3. Agent Mode Validation
+// ------------------------------------------------------------------
+describe("Agent Mode Validation", () => {
+  it("should have valid mode enum values in Agent.Info schema", async () => {
+    const { Agent } = await import("../agent/agent")
+    const validModes = ["subagent", "primary", "all"] as const
+
+    // The Info schema should have mode as an enum
+    const modeField = Agent.Info.shape.mode
+    expect(modeField).toBeDefined()
+
+    // Get the enum values from the zod schema
+    const enumValues = modeField.options
+    expect(enumValues).toBeDefined()
+    expect(Array.from(enumValues).sort()).toEqual([...validModes].sort())
+  })
+
+  it("should have required permission fields in Agent.Info schema", async () => {
+    const { Agent } = await import("../agent/agent")
+
+    const permissionShape = Agent.Info.shape.permission.shape
+    expect(permissionShape).toBeDefined()
+    expect(permissionShape.edit).toBeDefined()
+    expect(permissionShape.bash).toBeDefined()
+    expect(permissionShape.skill).toBeDefined()
+  })
+})
+
+// ------------------------------------------------------------------
+// 4. Tool Definition Validation
+// ------------------------------------------------------------------
+describe("Tool Definition Validation", () => {
+  const toolFiles = [
+    "bash",
+    "read",
+    "edit",
+    "write",
+    "glob",
+    "grep",
+    "task",
+    "webfetch",
+    "websearch",
+    "skill",
+    "todo",
+    "ls",
+    "lsp",
+  ]
+
+  for (const toolName of toolFiles) {
+    it(`should have valid Tool.define structure for ${toolName}`, async () => {
+      try {
+        const toolModule = await import(`../tool/${toolName}`)
+
+        // Find the exported tool (naming convention: XxxTool)
+        const toolExport = Object.values(toolModule).find(
+          (exp: any) => exp && typeof exp === "object" && "id" in exp && "init" in exp
+        ) as any
+
+        if (toolExport) {
+          expect(toolExport.id).toBeDefined()
+          expect(typeof toolExport.id).toBe("string")
+          expect(toolExport.init).toBeInstanceOf(Function)
+        }
+      } catch (err: any) {
+        // Some tools may have optional dependencies - that's ok for build check
+        if (!err.message.includes("Cannot find module")) {
+          throw err
+        }
+      }
+    })
+  }
+
+  it("should have id and init for all core tools", async () => {
+    const { BashTool } = await import("../tool/bash")
+    const { ReadTool } = await import("../tool/read")
+    const { EditTool } = await import("../tool/edit")
+    const { WriteTool } = await import("../tool/write")
+
+    const tools = [BashTool, ReadTool, EditTool, WriteTool]
+
+    for (const tool of tools) {
+      expect(tool.id).toBeDefined()
+      expect(typeof tool.id).toBe("string")
+      expect(tool.id.length).toBeGreaterThan(0)
+      expect(tool.init).toBeInstanceOf(Function)
+    }
+  })
+})
+
+// ------------------------------------------------------------------
+// 5. Prompt Template File Validation
+// ------------------------------------------------------------------
+describe("Prompt Template File Validation", () => {
+  const srcDir = path.join(__dirname, "..")
+
+  const requiredPromptFiles = [
+    // Agent prompts
+    "agent/generate.txt",
+    "agent/prompt/compaction.txt",
+    "agent/prompt/summary.txt",
+    "agent/prompt/title.txt",
+    // Tool prompts (description files)
+    "tool/bash.txt",
+    "tool/read.txt",
+    "tool/edit.txt",
+    "tool/write.txt",
+    "tool/glob.txt",
+    "tool/grep.txt",
+    "tool/task.txt",
+  ]
+
+  for (const file of requiredPromptFiles) {
+    it(`should have non-empty prompt file: ${file}`, () => {
+      const filePath = path.join(srcDir, file)
+      expect(fs.existsSync(filePath)).toBe(true)
+
+      const content = fs.readFileSync(filePath, "utf-8")
+      expect(content.length).toBeGreaterThan(0)
+      expect(content.trim().length).toBeGreaterThan(0)
+    })
+  }
+})
+
+// ------------------------------------------------------------------
+// 6. Config Schema Validation
+// ------------------------------------------------------------------
+describe("Config Schema Validation", () => {
+  it("should have valid Permission enum values", async () => {
+    const { Config } = await import("../config/config")
+
+    // Permission should be a zod enum
+    expect(Config.Permission).toBeDefined()
+    const permissionValues = Config.Permission.options
+    expect(permissionValues).toContain("allow")
+    expect(permissionValues).toContain("deny")
+    expect(permissionValues).toContain("ask")
+  })
+
+  it("should export core config functions", async () => {
+    const { Config } = await import("../config/config")
+
+    expect(Config.get).toBeInstanceOf(Function)
+    expect(Config.directories).toBeInstanceOf(Function)
+  })
+})
+
+// ------------------------------------------------------------------
+// 7. Export Structure Validation
+// ------------------------------------------------------------------
+describe("Export Structure Validation", () => {
+  it("should have Log utility with required methods", async () => {
+    const { Log } = await import("../util/log")
+
+    expect(Log).toBeDefined()
+    expect(Log.create).toBeInstanceOf(Function)
+  })
+
+  it("should have Instance with required properties", async () => {
+    const { Instance } = await import("../project/instance")
+
+    expect(Instance).toBeDefined()
+    expect(Instance.state).toBeInstanceOf(Function)
+    expect(Instance.provide).toBeInstanceOf(Function)
+  })
+
+  it("should have Permission namespace with required exports", async () => {
+    const { Permission } = await import("../permission")
+
+    expect(Permission).toBeDefined()
+    expect(Permission.ask).toBeInstanceOf(Function)
+    expect(Permission.RejectedError).toBeDefined()
+  })
+})