@opendash-ai/cli 0.1.0-beta.1 → 0.1.0-beta.2

package/test/tool/task.shell.test.ts

@@ -1,234 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import { Effect, Layer, ManagedRuntime } from "effect"
-import { Agent } from "../../src/agent/agent"
-import { Truncate } from "../../src/tool"
-import { TaskTool } from "../../src/tool/task"
-import { TaskRegistry } from "../../src/task/registry"
-
-const runtime = ManagedRuntime.make(
-  Layer.mergeAll(Truncate.defaultLayer, Agent.defaultLayer, TaskRegistry.defaultLayer),
-)
-
-async function parse(script: string) {
-  const info = await runtime.runPromise(TaskTool)
-  const def = await runtime.runPromise(info.init())
-  if (!def.shell) throw new Error("task tool has no shell field")
-  return runtime.runPromise(def.shell.parse(script))
-}
-
-async function parseFail(script: string) {
-  const info = await runtime.runPromise(TaskTool)
-  const def = await runtime.runPromise(info.init())
-  const exit = await runtime.runPromise(Effect.exit(def.shell!.parse(script)))
-  if (exit._tag !== "Failure") throw new Error("expected failure but got success")
-  const cause: any = (exit as any).cause
-  const fail = cause.reasons?.find?.((r: any) => r._tag === "Fail") ?? cause
-  return fail.error ?? fail
-}
-
-describe("task.shell.parse: basic verbs", () => {
-  test("create with summary", async () => {
-    const out = await parse('task create "Implement auth"')
-    expect(out).toEqual([{ operation: { action: "create", summary: "Implement auth" } }])
-  })
-
-  test("create subtask with --parent <TID>", async () => {
-    const out = await parse('task create "Email login" --parent T1')
-    expect(out).toEqual([{ operation: { action: "create", summary: "Email login", parent_id: "T1" } }])
-  })
-
-  test("create subtask with --parent=<TID> (equals form)", async () => {
-    const out = await parse('task create "OAuth" --parent=T2.1')
-    expect(out).toEqual([{ operation: { action: "create", summary: "OAuth", parent_id: "T2.1" } }])
-  })
-
-  test("list (no filter)", async () => {
-    const out = await parse("task list")
-    expect(out).toEqual([{ operation: { action: "list" } }])
-  })
-
-  test("list with status filter", async () => {
-    const out = await parse("task list open")
-    expect(out).toEqual([{ operation: { action: "list", status: "open" } }])
-  })
-
-  test("get by id", async () => {
-    const out = await parse("task get T1")
-    expect(out).toEqual([{ operation: { action: "get", id: "T1" } }])
-  })
-
-  test("rename", async () => {
-    const out = await parse('task rename T1 "Updated title"')
-    expect(out).toEqual([{ operation: { action: "rename", id: "T1", summary: "Updated title" } }])
-  })
-})
-
-describe("task.shell.parse: lifecycle verbs", () => {
-  test("block with reason", async () => {
-    const out = await parse('task block T1 "waiting on spec clarification"')
-    expect(out).toEqual([
-      { operation: { action: "block", id: "T1", event_summary: "waiting on spec clarification" } },
-    ])
-  })
-
-  test("unblock with reason", async () => {
-    const out = await parse('task unblock T1 "spec resolved"')
-    expect(out).toEqual([
-      { operation: { action: "unblock", id: "T1", event_summary: "spec resolved" } },
-    ])
-  })
-
-  test("done with summary", async () => {
-    const out = await parse('task done T1 "all tests pass"')
-    expect(out).toEqual([
-      { operation: { action: "done", id: "T1", event_summary: "all tests pass" } },
-    ])
-  })
-
-  test("abandon with reason", async () => {
-    const out = await parse('task abandon T1 "out of scope"')
-    expect(out).toEqual([
-      { operation: { action: "abandon", id: "T1", event_summary: "out of scope" } },
-    ])
-  })
-})
-
-describe("task.shell.parse: dispatch errors", () => {
-  test("unknown verb suggests close match (creat → create)", async () => {
-    const err = await parseFail("task creat T1")
-    expect(err.kind).toBe("unknown-verb")
-    expect(err.detail).toContain("did you mean: create")
-  })
-
-  test("unknown verb suggests close match (donee → done)", async () => {
-    const err = await parseFail("task donee T1")
-    expect(err.kind).toBe("unknown-verb")
-    expect(err.detail).toContain("did you mean: done")
-  })
-
-  test("create with wrong arity reports got/expected", async () => {
-    const err = await parseFail("task create")
-    expect(err.kind).toBe("arity")
-    expect(err.detail).toContain("expected: task create <summary>")
-  })
-
-  test("block missing reason reports arity error", async () => {
-    const err = await parseFail("task block T1")
-    expect(err.kind).toBe("arity")
-    expect(err.detail).toContain("expected: task block <id> <reason>")
-  })
-
-  test("done missing summary reports arity error", async () => {
-    const err = await parseFail("task done T1")
-    expect(err.kind).toBe("arity")
-    expect(err.detail).toContain("expected: task done <id> <summary>")
-  })
-})
-
-describe("task.shell.parse: multi-command", () => {
-  test("two creates via newlines", async () => {
-    const out = await parse('task create "A"\ntask create "B"')
-    expect(out).toEqual([
-      { operation: { action: "create", summary: "A" } },
-      { operation: { action: "create", summary: "B" } },
-    ])
-  })
-
-  test("mixed lifecycle commands", async () => {
-    const out = await parse('task create "Implement auth"\ntask done T1 "complete"')
-    expect(out).toEqual([
-      { operation: { action: "create", summary: "Implement auth" } },
-      { operation: { action: "done", id: "T1", event_summary: "complete" } },
-    ])
-  })
-})
-
-describe("task.shell.parse: start", () => {
-  test("start by id", async () => {
-    const out = await parse("task start T1")
-    expect(out).toEqual([{ operation: { action: "start", id: "T1" } }])
-  })
-  test("unstart is no longer a valid verb", async () => {
-    const err = await parseFail("task unstart T1")
-    expect(err.kind).toBe("unknown-verb")
-  })
-  test("start arity error with no id", async () => {
-    const err = await parseFail("task start")
-    expect(err).toBeDefined()
-  })
-})
-
-describe("task.shell: deprecated verbs", () => {
-  test("task progress reports unknown verb", async () => {
-    const err = await parseFail('task progress T1 "x"')
-    expect(err.kind).toBe("unknown-verb")
-  })
-
-  test("task revise reports unknown verb", async () => {
-    const err = await parseFail("task revise T1 body x")
-    expect(err.kind).toBe("unknown-verb")
-  })
-
-  test("task create_sub reports unknown verb", async () => {
-    const err = await parseFail('task create_sub T1 "x"')
-    expect(err.kind).toBe("unknown-verb")
-  })
-
-  test("task unblock maps to unblock op", async () => {
-    const out = await parse('task unblock T1 "spec resolved"')
-    expect(out).toEqual([
-      { operation: { action: "unblock", id: "T1", event_summary: "spec resolved" } },
-    ])
-  })
-})
-
-describe("task.shell.parse: parity flags", () => {
-  test("create with --session", async () => {
-    const out = await parse('task create "X" --session ses_abc')
-    expect(out).toEqual([{ operation: { action: "create", summary: "X", session_id: "ses_abc" } }])
-  })
-  test("create with --parent and --session", async () => {
-    const out = await parse('task create "X" --parent T1 --session ses_abc')
-    expect(out).toEqual([{ operation: { action: "create", summary: "X", parent_id: "T1", session_id: "ses_abc" } }])
-  })
-  test("start with --reason maps to event_summary", async () => {
-    const out = await parse('task start T1 --reason "picking this up"')
-    expect(out).toEqual([{ operation: { action: "start", id: "T1", event_summary: "picking this up" } }])
-  })
-  test("start with --session", async () => {
-    const out = await parse("task start T1 --session ses_abc")
-    expect(out).toEqual([{ operation: { action: "start", id: "T1", session_id: "ses_abc" } }])
-  })
-  test("get with --session", async () => {
-    const out = await parse("task get T1 --session ses_abc")
-    expect(out).toEqual([{ operation: { action: "get", id: "T1", session_id: "ses_abc" } }])
-  })
-  test("list with --include-terminal and --include-archived (booleans)", async () => {
-    const out = await parse("task list --include-terminal --include-archived")
-    expect(out).toEqual([{ operation: { action: "list", include_terminal: true, include_archived: true } }])
-  })
-  test("list with status and --session", async () => {
-    const out = await parse("task list open --session ses_abc")
-    expect(out).toEqual([{ operation: { action: "list", status: "open", session_id: "ses_abc" } }])
-  })
-  test("done with reason and --session", async () => {
-    const out = await parse('task done T1 "all tests pass" --session ses_abc')
-    expect(out).toEqual([{ operation: { action: "done", id: "T1", event_summary: "all tests pass", session_id: "ses_abc" } }])
-  })
-  test("rename with --session", async () => {
-    const out = await parse('task rename T1 "New title" --session ses_abc')
-    expect(out).toEqual([{ operation: { action: "rename", id: "T1", summary: "New title", session_id: "ses_abc" } }])
-  })
-
-  test("dangling value flag (--session with no value) errors, not silent drop", async () => {
-    const err = await parseFail("task get T1 --session")
-    expect(err.kind).toBe("flag")
-    expect(err.detail).toContain("--session requires a value")
-  })
-
-  test("empty value flag (--session=) errors", async () => {
-    const err = await parseFail("task get T1 --session=")
-    expect(err.kind).toBe("flag")
-    expect(err.detail).toContain("--session requires a value")
-  })
-})

package/test/tool/task.test.ts

@@ -1,296 +0,0 @@
-import { afterEach, describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { Agent } from "../../src/agent/agent"
-import { Bus } from "../../src/bus"
-import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
-import { Instance } from "../../src/project/instance"
-import { Session } from "../../src/session"
-import { MessageID, SessionID } from "../../src/session/schema"
-import { TaskRegistry } from "../../src/task/registry"
-import { Truncate } from "../../src/tool"
-import { TaskTool } from "../../src/tool/task"
-import { shellWrap } from "../../src/tool/shell-wrap"
-import { provideTmpdirInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-afterEach(async () => {
-  await Instance.disposeAll()
-})
-
-const it = testEffect(
-  Layer.mergeAll(
-    Bus.defaultLayer,
-    CrossSpawnSpawner.defaultLayer,
-    Session.defaultLayer,
-    TaskRegistry.defaultLayer,
-    Truncate.defaultLayer,
-    Agent.defaultLayer,
-  ),
-)
-
-const ctx = (sessionID: string) => ({
-  sessionID: SessionID.make(sessionID),
-  messageID: MessageID.ascending(),
-  agent: "build",
-  abort: new AbortController().signal,
-  messages: [],
-  metadata: () => Effect.void,
-  ask: () => Effect.void,
-})
-
-describe("task tool", () => {
-  it.live("create with summary returns new task id", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const tool = yield* info.init()
-        const result = yield* tool.execute({ operation: { action: "create", summary: "Implement auth" } }, ctx(sess.id))
-        expect(result.output).toContain("T1")
-        expect(result.metadata.id).toBe("T1")
-      }),
-    ),
-  )
-
-  it.live("list returns tasks for current session", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const reg = yield* TaskRegistry.Service
-        const sess = yield* session.create({ title: "Test" })
-        yield* reg.create({ session_id: sess.id, summary: "a" })
-        yield* reg.create({ session_id: sess.id, summary: "b" })
-        const info = yield* TaskTool
-        const tool = yield* info.init()
-        const result = yield* tool.execute({ operation: { action: "list" } }, ctx(sess.id))
-        expect(result.metadata.count).toBe(2)
-      }),
-    ),
-  )
-
-  it.live("set_status=done transitions task", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const reg = yield* TaskRegistry.Service
-        const sess = yield* session.create({ title: "Test" })
-        const t = yield* reg.create({ session_id: sess.id, summary: "a" })
-        const info = yield* TaskTool
-        const tool = yield* info.init()
-        yield* tool.execute({ operation: { action: "done", id: t.id } }, ctx(sess.id))
-        const after = yield* reg.get({ session_id: sess.id, id: t.id })
-        expect(after?.status).toBe("done")
-      }),
-    ),
-  )
-
-  it.live("rename with summary renames the task", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const reg = yield* TaskRegistry.Service
-        const sess = yield* session.create({ title: "Test" })
-        const t = yield* reg.create({ session_id: sess.id, summary: "old name" })
-        const info = yield* TaskTool
-        const tool = yield* info.init()
-        yield* tool.execute({ operation: { action: "rename", id: t.id, summary: "new name" } }, ctx(sess.id))
-        const after = yield* reg.get({ session_id: sess.id, id: t.id })
-        expect(after?.summary).toBe("new name")
-      }),
-    ),
-  )
-
-  it.live("rejects old flat JSON shape", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const tool = yield* info.init()
-        const exit = yield* Effect.exit(
-          tool.execute({ action: "create", summary: "Implement auth" } as any, ctx(sess.id)),
-        )
-        expect(exit._tag).toBe("Failure")
-      }),
-    ),
-  )
-
-  it.live("rejects create without summary", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const tool = yield* info.init()
-        const exit = yield* Effect.exit(tool.execute({ operation: { action: "create" } } as any, ctx(sess.id)))
-        expect(exit._tag).toBe("Failure")
-      }),
-    ),
-  )
-
-  it.live("rejects progress without event_summary", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const reg = yield* TaskRegistry.Service
-        const sess = yield* session.create({ title: "Test" })
-        const t = yield* reg.create({ session_id: sess.id, summary: "a" })
-        const info = yield* TaskTool
-        const tool = yield* info.init()
-        const exit = yield* Effect.exit(
-          tool.execute({ operation: { action: "progress", id: t.id } } as any, ctx(sess.id)),
-        )
-        expect(exit._tag).toBe("Failure")
-      }),
-    ),
-  )
-})
-
-describe("task tool: deprecated verbs are rejected", () => {
-  it.live("set_status operation itself is rejected (replaced by independent verbs)", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const tool = yield* info.init()
-        const exit = yield* Effect.exit(
-          tool.execute({ operation: { action: "set_status", id: "T1", status: "blocked" } } as any, ctx(sess.id)),
-        )
-        expect(exit._tag).toBe("Failure")
-      }),
-    ),
-  )
-
-  it.live("progress operation is rejected", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const tool = yield* info.init()
-        const exit = yield* Effect.exit(
-          tool.execute({ operation: { action: "progress", id: "T1", event_summary: "x" } } as any, ctx(sess.id)),
-        )
-        expect(exit._tag).toBe("Failure")
-      }),
-    ),
-  )
-
-  it.live("approve operation is rejected", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const tool = yield* info.init()
-        const exit = yield* Effect.exit(
-          tool.execute({ operation: { action: "approve", id: "T1" } } as any, ctx(sess.id)),
-        )
-        expect(exit._tag).toBe("Failure")
-      }),
-    ),
-  )
-
-  it.live("rename with spec_ref is rejected", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const tool = yield* info.init()
-        const exit = yield* Effect.exit(
-          tool.execute({ operation: { action: "rename", id: "T1", spec_ref: "x" } } as any, ctx(sess.id)),
-        )
-        expect(exit._tag).toBe("Failure")
-      }),
-    ),
-  )
-})
-
-describe("task tool: independent lifecycle verbs", () => {
-  it.live("block operation accepted", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const def = yield* info.init()
-        const result = def.parameters.safeParse({ operation: { action: "block", id: "T1", event_summary: "waiting" } })
-        expect(result.success).toBe(true)
-      }),
-    ),
-  )
-
-  it.live("unblock operation accepted", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const def = yield* info.init()
-        const result = def.parameters.safeParse({ operation: { action: "unblock", id: "T1" } })
-        expect(result.success).toBe(true)
-      }),
-    ),
-  )
-
-  it.live("done operation accepted", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const def = yield* info.init()
-        const result = def.parameters.safeParse({ operation: { action: "done", id: "T1", event_summary: "complete" } })
-        expect(result.success).toBe(true)
-      }),
-    ),
-  )
-
-  it.live("abandon operation accepted", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const def = yield* info.init()
-        const result = def.parameters.safeParse({ operation: { action: "abandon", id: "T1" } })
-        expect(result.success).toBe(true)
-      }),
-    ),
-  )
-
-  it.live("block with invalid status field is rejected (strict)", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const def = yield* info.init()
-        const result = def.parameters.safeParse({ operation: { action: "block", id: "T1", status: "in_progress" } })
-        expect(result.success).toBe(false)
-      }),
-    ),
-  )
-
-  it.live("shell-wrapped task create does not crash and renders operation=create", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const session = yield* Session.Service
-        const sess = yield* session.create({ title: "Test" })
-        const info = yield* TaskTool
-        const def = yield* info.init()
-        const wrapped = shellWrap({ ...def, id: info.id })
-        const result = yield* wrapped.execute({ script: 'task create "x"' }, ctx(sess.id) as any)
-        // Regression: nested discriminator { operation: { action } } used to crash
-        // shell-wrap with "H.replace is not a function". The XML attribute must
-        // reflect the action verb, not "[object Object]".
-        expect(result.output).toContain('operation="create"')
-        expect(result.output).not.toContain("[object Object]")
-        expect(result.metadata.success).toBe(1)
-      }),
-    ),
-  )
-})

package/test/tool/tool-def-shell-shape.test.ts

@@ -1,23 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import { Effect } from "effect"
-import z from "zod"
-import type { Tool } from "../../src/tool"
-
-describe("Tool.Def shell field shape", () => {
-  test("Def accepts a shell field whose parse returns Effect of args[]", () => {
-    const params = z.object({ action: z.string(), id: z.string().optional() })
-    const def: Tool.Def<typeof params> = {
-      id: "synthetic",
-      description: "json",
-      parameters: params,
-      execute: () => Effect.succeed({ title: "", output: "", metadata: {} }),
-      shell: {
-        description: "shell",
-        parse: (_script) =>
-          Effect.succeed([{ action: "noop" } as z.infer<typeof params>]),
-      },
-    }
-    expect(def.shell?.description).toBe("shell")
-    expect(typeof def.shell?.parse).toBe("function")
-  })
-})

package/test/tool/tool-define.test.ts

@@ -1,59 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import { Effect, Layer, ManagedRuntime } from "effect"
-import z from "zod"
-import { Agent } from "../../src/agent/agent"
-import { Tool } from "../../src/tool"
-import { Truncate } from "../../src/tool"
-
-const runtime = ManagedRuntime.make(Layer.mergeAll(Truncate.defaultLayer, Agent.defaultLayer))
-
-const params = z.object({ input: z.string() })
-
-function makeTool(id: string, executeFn?: () => void) {
-  return {
-    description: "test tool",
-    parameters: params,
-    execute() {
-      executeFn?.()
-      return Effect.succeed({ title: "test", output: "ok", metadata: {} })
-    },
-  }
-}
-
-describe("Tool.define", () => {
-  test("object-defined tool does not mutate the original init object", async () => {
-    const original = makeTool("test")
-    const originalExecute = original.execute
-
-    const info = await runtime.runPromise(Tool.define("test-tool", Effect.succeed(original)))
-
-    await Effect.runPromise(info.init())
-    await Effect.runPromise(info.init())
-    await Effect.runPromise(info.init())
-
-    expect(original.execute).toBe(originalExecute)
-  })
-
-  test("effect-defined tool returns fresh objects and is unaffected", async () => {
-    const info = await runtime.runPromise(
-      Tool.define(
-        "test-fn-tool",
-        Effect.succeed(() => Effect.succeed(makeTool("test"))),
-      ),
-    )
-
-    const first = await Effect.runPromise(info.init())
-    const second = await Effect.runPromise(info.init())
-
-    expect(first).not.toBe(second)
-  })
-
-  test("object-defined tool returns distinct objects per init() call", async () => {
-    const info = await runtime.runPromise(Tool.define("test-copy", Effect.succeed(makeTool("test"))))
-
-    const first = await Effect.runPromise(info.init())
-    const second = await Effect.runPromise(info.init())
-
-    expect(first).not.toBe(second)
-  })
-})

package/test/tool/tool-validation-error.test.ts

@@ -1,25 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import z from "zod"
-import { validationErrorMessage } from "../../src/tool/tool"
-
-describe("validationErrorMessage", () => {
-  const result = z
-    .object({ operation: z.object({ subagent_type: z.enum(["general", "explore"]) }) })
-    .safeParse({ operation: { subagent_type: "foo" } })
-
-  test("ZodError yields zod's prettified, path-annotated message (not generic boilerplate)", () => {
-    expect(result.success).toBe(false)
-    if (result.success) return
-    const msg = validationErrorMessage("actor", result.error)
-    expect(msg).toContain("actor") // names the tool
-    expect(msg).toContain("subagent_type") // surfaces the offending field path
-    expect(msg).toContain("general") // surfaces the expected values
-    expect(msg).not.toContain("satisfies the expected schema") // dropped the filler
-  })
-
-  test("non-Zod error falls back to a generic actionable message", () => {
-    const msg = validationErrorMessage("read", new Error("boom"))
-    expect(msg).toContain("read")
-    expect(msg.toLowerCase()).toContain("invalid arguments")
-  })
-})