artificial-code 1.17.13 → 1.17.14

package/test/session/schema-decoding.test.ts

@@ -1,313 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Schema } from "effect"
-
-import { Session } from "@/session/session"
-import { SessionPrompt } from "../../src/session/prompt"
-import { SessionRevert } from "../../src/session/revert"
-import { SessionStatus } from "../../src/session/status"
-import { SessionSummary } from "../../src/session/summary"
-import { Todo } from "../../src/session/todo"
-import { SessionID, MessageID, PartID } from "../../src/session/schema"
-import { ProjectV2 } from "@ac/core/project"
-import { WorkspaceV2 } from "@ac/core/workspace"
-
-// Covers the session-domain Effect Schema migration. For each migrated
-// schema we assert:
-//   1. The Effect decoder (`Schema.decodeUnknownSync`) accepts valid input.
-//   2. Clearly-invalid input is rejected.
-
-// Representative valid IDs — the branded schemas require the right prefix
-// (see src/id/id.ts).
-const sessionID = Schema.decodeUnknownSync(SessionID)("ses_01J5Y5H0AH4Q4NXJ6P4C3P5V2K")
-const sessionIDChild = Schema.decodeUnknownSync(SessionID)("ses_01J5Y5H0AH4Q4NXJ6P4C3P5V2L")
-const messageID = Schema.decodeUnknownSync(MessageID)("msg_01J5Y5H0AH4Q4NXJ6P4C3P5V2M")
-const partID = Schema.decodeUnknownSync(PartID)("prt_01J5Y5H0AH4Q4NXJ6P4C3P5V2N")
-const projectID = ProjectV2.ID.make("proj-alpha")
-const workspaceID = Schema.decodeUnknownSync(WorkspaceV2.ID)("wrk-primary")
-
-function decodeUnknown<S extends Schema.Top>(schema: S) {
-  const decode = Schema.decodeUnknownSync(schema as any)
-  return (input: unknown): Schema.Schema.Type<S> => decode(input) as Schema.Schema.Type<S>
-}
-
-describe("Session.Info", () => {
-  const decode = decodeUnknown(Session.Info)
-
-  test("accepts minimal session", () => {
-    const input = {
-      id: sessionID,
-      slug: "hello",
-      projectID,
-      directory: "/tmp/proj",
-      title: "First session",
-      version: "0.1.0",
-      time: { created: 1, updated: 2 },
-    }
-    expect(decode(input)).toEqual(input)
-  })
-
-  test("round-trips every optional field", () => {
-    const input = {
-      id: sessionID,
-      slug: "fullshape",
-      projectID,
-      workspaceID,
-      directory: "/tmp/proj",
-      path: "packages/opencode",
-      parentID: sessionIDChild,
-      summary: {
-        additions: 10,
-        deletions: 5,
-        files: 2,
-        diffs: [{ additions: 1, deletions: 0, file: "a.ts", patch: "--- a/a.ts" }],
-      },
-      share: { url: "https://share.example.com/s/1" },
-      title: "Full session",
-      version: "1.0.0",
-      metadata: { source: "test" },
-      time: { created: 100, updated: 200, compacting: 150, archived: 300 },
-      permission: [{ action: "allow" as const, pattern: "*", permission: "read" }],
-      revert: {
-        messageID,
-        partID,
-        snapshot: "snap-1",
-        diff: "diff-1",
-      },
-    }
-    expect(decode(input)).toEqual(input)
-  })
-
-  test("accepts migrated summary diffs without file details", () => {
-    const input = {
-      id: sessionID,
-      slug: "legacy-diff",
-      projectID,
-      directory: "/tmp/proj",
-      title: "Legacy diff",
-      version: "0.1.0",
-      summary: {
-        additions: 1,
-        deletions: 0,
-        files: 1,
-        diffs: [{ additions: 1, deletions: 0 }],
-      },
-      time: { created: 1, updated: 2 },
-    }
-    expect(decode(input)).toEqual(input)
-  })
-
-  test("rejects unbranded session id", () => {
-    const bad = { id: "not-a-session-id" } as unknown
-    expect(() => decode(bad)).toThrow()
-  })
-
-  test("rejects missing required fields", () => {
-    const bad = { id: sessionID } as unknown
-    expect(() => decode(bad)).toThrow()
-  })
-})
-
-describe("Session.ProjectInfo", () => {
-  const decode = decodeUnknown(Session.ProjectInfo)
-
-  test("accepts with and without optional name", () => {
-    const noName = { id: projectID, worktree: "/tmp/wt" }
-    const withName = { ...noName, name: "alpha" }
-    expect(decode(noName)).toEqual(noName)
-    expect(decode(withName)).toEqual(withName)
-  })
-})
-
-describe("Session.GlobalInfo", () => {
-  const decode = decodeUnknown(Session.GlobalInfo)
-
-  test("accepts null project", () => {
-    const input = {
-      id: sessionID,
-      slug: "global",
-      projectID,
-      directory: "/tmp/proj",
-      title: "global",
-      version: "0",
-      time: { created: 0, updated: 0 },
-      project: null,
-    }
-    expect(decode(input)).toEqual(input)
-  })
-
-  test("accepts populated project", () => {
-    const input = {
-      id: sessionID,
-      slug: "global",
-      projectID,
-      directory: "/tmp/proj",
-      title: "global",
-      version: "0",
-      time: { created: 0, updated: 0 },
-      project: { id: projectID, worktree: "/tmp/wt", name: "alpha" },
-    }
-    expect(decode(input)).toEqual(input)
-  })
-})
-
-describe("Session input schemas", () => {
-  test("CreateInput accepts undefined and populated forms", () => {
-    const decode = decodeUnknown(Session.CreateInput)
-    expect(decode(undefined)).toBeUndefined()
-
-    const populated = {
-      parentID: sessionID,
-      title: "child",
-      metadata: { source: "test" },
-      permission: [{ action: "ask" as const, pattern: "*", permission: "bash" }],
-      workspaceID,
-    }
-    expect(decode(populated)).toEqual(populated)
-  })
-
-  test("ForkInput round-trips", () => {
-    const decode = decodeUnknown(Session.ForkInput)
-    const input = { sessionID, messageID }
-    expect(decode(input)).toEqual(input)
-    // messageID is optional
-    const bare = { sessionID }
-    expect(decode(bare)).toEqual(bare)
-  })
-
-  test("SetTitleInput rejects missing title", () => {
-    expect(() => decodeUnknown(Session.SetTitleInput)({ sessionID })).toThrow()
-  })
-
-  test("SetArchivedInput accepts both with and without time", () => {
-    const decode = decodeUnknown(Session.SetArchivedInput)
-    expect(decode({ sessionID })).toEqual({ sessionID })
-    expect(decode({ sessionID, time: 123 })).toEqual({ sessionID, time: 123 })
-  })
-
-  test("SetPermissionInput requires a ruleset", () => {
-    const decode = decodeUnknown(Session.SetPermissionInput)
-    const input = { sessionID, permission: [{ action: "deny" as const, pattern: "*", permission: "write" }] }
-    expect(decode(input)).toEqual(input)
-    expect(() => decode({ sessionID })).toThrow()
-  })
-
-  test("MessagesInput accepts optional limit", () => {
-    const decode = decodeUnknown(Session.MessagesInput)
-    expect(decode({ sessionID })).toEqual({ sessionID })
-    expect(decode({ sessionID, limit: 50 })).toEqual({ sessionID, limit: 50 })
-  })
-})
-
-describe("SessionRevert.RevertInput", () => {
-  const decode = decodeUnknown(SessionRevert.RevertInput)
-
-  test("messageID is required, partID is optional", () => {
-    const withPart = { sessionID, messageID, partID }
-    expect(decode(withPart)).toEqual(withPart)
-
-    const noPart = { sessionID, messageID }
-    expect(decode(noPart)).toEqual(noPart)
-
-    expect(() => decode({ sessionID })).toThrow()
-  })
-})
-
-describe("SessionSummary.DiffInput", () => {
-  const decode = decodeUnknown(SessionSummary.DiffInput)
-
-  test("messageID optional", () => {
-    expect(decode({ sessionID })).toEqual({ sessionID })
-    expect(decode({ sessionID, messageID })).toEqual({ sessionID, messageID })
-  })
-})
-
-describe("SessionStatus.Info", () => {
-  const decode = decodeUnknown(SessionStatus.Info)
-
-  test("idle / busy discriminators", () => {
-    expect(decode({ type: "idle" })).toEqual({ type: "idle" })
-    expect(decode({ type: "busy" })).toEqual({ type: "busy" })
-  })
-
-  test("retry carries attempt/message/action/next", () => {
-    const input = {
-      type: "retry" as const,
-      attempt: 1,
-      message: "transient",
-      action: {
-        reason: "free_tier_limit",
-        provider: "opencode",
-        title: "Free limit reached",
-        message: "Subscribe to OpenCode Go.",
-        label: "subscribe",
-        link: "https://opencode.ai/go",
-      },
-      next: 500,
-    }
-    expect(decode(input)).toEqual(input)
-  })
-
-  test("rejects unknown type", () => {
-    expect(() => decode({ type: "bogus" })).toThrow()
-  })
-})
-
-describe("Todo.Info", () => {
-  const decode = decodeUnknown(Todo.Info)
-
-  test("three-field round-trip", () => {
-    const input = Todo.Info.make({ content: "do a thing", status: "pending", priority: "high" })
-    expect(decode(input)).toEqual(input)
-  })
-})
-
-describe("SessionPrompt input schemas", () => {
-  test("LoopInput is just sessionID", () => {
-    const decode = decodeUnknown(SessionPrompt.LoopInput)
-    expect(decode({ sessionID })).toEqual({ sessionID })
-  })
-
-  test("ShellInput requires agent + command", () => {
-    const decode = decodeUnknown(SessionPrompt.ShellInput)
-    const expected = { sessionID, agent: "build", command: "echo hi" }
-    const input: unknown = expected
-    expect(decode(input)).toEqual(expected)
-    expect(() => decode({ sessionID })).toThrow()
-  })
-
-  test("PromptInput accepts a text part and a file part", () => {
-    const decode = decodeUnknown(SessionPrompt.PromptInput)
-    const expected = {
-      sessionID,
-      parts: [
-        { type: "text" as const, text: "hello" },
-        { type: "file" as const, mime: "image/png", url: "data:image/png;base64,AAAA" },
-      ],
-    }
-    const input: unknown = expected
-    const decoded = decode(input)
-    expect(decoded.parts).toHaveLength(2)
-    expect(decoded.parts[0]).toMatchObject({ type: "text", text: "hello" })
-    expect(decoded.parts[1]).toMatchObject({ type: "file", mime: "image/png" })
-  })
-
-  test("PromptInput rejects unknown part type", () => {
-    const decode = decodeUnknown(SessionPrompt.PromptInput)
-    const bad = {
-      sessionID,
-      parts: [{ type: "nonsense", payload: 42 }],
-    }
-    expect(() => decode(bad)).toThrow()
-  })
-
-  test("CommandInput round-trips core fields", () => {
-    const decode = decodeUnknown(SessionPrompt.CommandInput)
-    const expected = {
-      sessionID,
-      arguments: "--flag",
-      command: "deploy",
-    }
-    const input: unknown = expected
-    expect(decode(input)).toEqual(expected)
-  })
-})

package/test/session/session-schema.test.ts

@@ -1,78 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Schema } from "effect"
-import { ProjectV2 } from "@ac/core/project"
-import { MessageID, SessionID } from "../../src/session/schema"
-import { Session } from "../../src/session/session"
-
-const info = {
-  id: SessionID.descending(),
-  slug: "test-session",
-  projectID: ProjectV2.ID.global,
-  workspaceID: undefined,
-  directory: "/tmp/opencode",
-  parentID: undefined,
-  summary: undefined,
-  cost: 0,
-  tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-  share: undefined,
-  title: "Test session",
-  version: "1.0.0",
-  time: {
-    created: 1,
-    updated: 2,
-    compacting: undefined,
-    archived: undefined,
-  },
-  permission: undefined,
-  revert: undefined,
-} satisfies Session.Info
-
-describe("Session schema", () => {
-  test("encodes undefined optional session fields as omitted keys", () => {
-    const encoded = Schema.encodeUnknownSync(Session.Info)(info) as Record<string, unknown>
-
-    for (const key of ["workspaceID", "parentID", "summary", "share", "permission", "revert"]) {
-      expect(Object.hasOwn(encoded, key)).toBe(false)
-    }
-    expect(Object.hasOwn(encoded.time as Record<string, unknown>, "compacting")).toBe(false)
-    expect(Object.hasOwn(encoded.time as Record<string, unknown>, "archived")).toBe(false)
-    expect(JSON.stringify(encoded)).not.toContain("parentID")
-  })
-
-  test("encodes undefined optional global session project fields as omitted keys", () => {
-    const encoded = Schema.encodeUnknownSync(Session.GlobalInfo)({
-      ...info,
-      project: {
-        id: ProjectV2.ID.global,
-        name: undefined,
-        worktree: "/tmp/opencode",
-      },
-    }) as Record<string, unknown>
-
-    expect(Object.hasOwn(encoded, "parentID")).toBe(false)
-    expect(Object.hasOwn(encoded.project as Record<string, unknown>, "name")).toBe(false)
-  })
-
-  test("encodes nested undefined optional session fields as omitted keys", () => {
-    const encoded = Schema.encodeUnknownSync(Session.Info)({
-      ...info,
-      summary: {
-        additions: 1,
-        deletions: 2,
-        files: 3,
-        diffs: undefined,
-      },
-      revert: {
-        messageID: MessageID.ascending(),
-        partID: undefined,
-        snapshot: undefined,
-        diff: undefined,
-      },
-    }) as Record<string, unknown>
-
-    expect(Object.hasOwn(encoded.summary as Record<string, unknown>, "diffs")).toBe(false)
-    for (const key of ["partID", "snapshot", "diff"]) {
-      expect(Object.hasOwn(encoded.revert as Record<string, unknown>, key)).toBe(false)
-    }
-  })
-})

package/test/session/session.test.ts

@@ -1,253 +0,0 @@
-import { describe, expect } from "bun:test"
-import { SessionV1 } from "@ac/core/v1/session"
-import { EventV2 } from "@ac/core/event"
-import { SessionProjector } from "@ac/core/session/projector"
-import { Deferred, Effect, Exit, Layer } from "effect"
-import { Session as SessionNs } from "@/session/session"
-import { MessageV2 } from "../../src/session/message-v2"
-import { MessageID, PartID, type SessionID } from "../../src/session/schema"
-import { CrossSpawnSpawner } from "@ac/core/cross-spawn-spawner"
-import { provideInstance, tmpdirScoped } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-import { RuntimeFlags } from "@/effect/runtime-flags"
-import { EventV2Bridge } from "@/event-v2-bridge"
-import { GlobalBus } from "@/bus/global"
-import { AppNodeBuilder } from "@ac/core/effect/app-node-builder"
-import { LayerNode } from "@ac/core/effect/layer-node"
-import { InstanceStore } from "@/project/instance-store"
-import { InstanceBootstrap } from "@/project/bootstrap"
-
-const it = testEffect(
-  AppNodeBuilder.build(
-    LayerNode.group([
-      SessionNs.node,
-      EventV2Bridge.node,
-      SessionProjector.node,
-      CrossSpawnSpawner.node,
-      InstanceStore.node,
-    ]),
-    [
-      [RuntimeFlags.node, RuntimeFlags.layer({ experimentalWorkspaces: false })],
-      [
-        InstanceBootstrap.node,
-        Layer.succeed(InstanceBootstrap.Service, InstanceBootstrap.Service.of({ run: Effect.void })),
-      ],
-    ],
-  ),
-)
-
-const awaitDeferred = <T>(deferred: Deferred.Deferred<T>, message: string) =>
-  Effect.race(
-    Deferred.await(deferred),
-    Effect.sleep("2 seconds").pipe(Effect.flatMap(() => Effect.fail(new Error(message)))),
-  )
-
-const remove = (id: SessionID) => SessionNs.use.remove(id)
-
-describe("session.created event", () => {
-  it.instance("should emit session.created event when session is created", () =>
-    Effect.gen(function* () {
-      const session = yield* SessionNs.Service
-      const events = yield* EventV2Bridge.Service
-      const received = yield* Deferred.make<SessionNs.Info>()
-
-      const unsub = yield* events.listen((event) => {
-        if (event.type === SessionNs.Event.Created.type)
-          Deferred.doneUnsafe(
-            received,
-            Effect.succeed((event.data as typeof SessionNs.Event.Created.data.Type).info as SessionNs.Info),
-          )
-        return Effect.void
-      })
-      yield* Effect.addFinalizer(() => unsub)
-
-      const info = yield* session.create({})
-      const receivedInfo = yield* awaitDeferred(received, "timed out waiting for session.created")
-
-      expect(receivedInfo.id).toBe(info.id)
-      expect(receivedInfo.projectID).toBe(info.projectID)
-      expect(receivedInfo.directory).toBe(info.directory)
-      expect(receivedInfo.path).toBe(info.path)
-      expect(receivedInfo.title).toBe(info.title)
-
-      yield* session.remove(info.id)
-    }),
-  )
-
-  it.instance("session.created event should be emitted before session.updated", () =>
-    Effect.gen(function* () {
-      const session = yield* SessionNs.Service
-      const source = yield* EventV2Bridge.Service
-      const events: string[] = []
-      const received = yield* Deferred.make<string[]>()
-      const push = (event: string) => {
-        events.push(event)
-        if (events.includes("created") && events.includes("updated")) {
-          Deferred.doneUnsafe(received, Effect.succeed(events))
-        }
-      }
-
-      const unsubscribe = yield* source.listen((event) => {
-        if (event.type === SessionNs.Event.Created.type) push("created")
-        if (event.type === SessionNs.Event.Updated.type) push("updated")
-        return Effect.void
-      })
-      yield* Effect.addFinalizer(() => unsubscribe)
-
-      const info = yield* session.create({})
-      yield* session.setTitle({ sessionID: info.id, title: "updated" })
-      const receivedEvents = yield* awaitDeferred(received, "timed out waiting for session created/updated events")
-
-      expect(receivedEvents).toContain("created")
-      expect(receivedEvents).toContain("updated")
-      expect(receivedEvents.indexOf("created")).toBeLessThan(receivedEvents.indexOf("updated"))
-
-      yield* session.remove(info.id)
-    }),
-  )
-
-  it.instance("emits legacy global sync payload", () =>
-    Effect.gen(function* () {
-      const session = yield* SessionNs.Service
-      const received = yield* Deferred.make<{ syncEvent: EventV2.SerializedEvent }>()
-      const listener = (event: { payload: { type?: string; syncEvent?: EventV2.SerializedEvent } }) => {
-        if (event.payload.type === "sync" && event.payload.syncEvent)
-          Deferred.doneUnsafe(received, Effect.succeed({ syncEvent: event.payload.syncEvent }))
-      }
-      GlobalBus.on("event", listener)
-      yield* Effect.addFinalizer(() => Effect.sync(() => GlobalBus.off("event", listener)))
-
-      const info = yield* session.create({})
-      const event = yield* awaitDeferred(received, "timed out waiting for legacy global sync event")
-
-      expect(event.syncEvent).toMatchObject({
-        type: EventV2.versionedType(SessionNs.Event.Created.type, 1),
-        seq: 0,
-        aggregateID: info.id,
-        data: { sessionID: info.id },
-      })
-
-      yield* session.remove(info.id)
-    }),
-  )
-})
-
-describe("step-finish token propagation via event", () => {
-  it.instance(
-    "non-zero tokens propagate through PartUpdated event",
-    () =>
-      Effect.gen(function* () {
-        const session = yield* SessionNs.Service
-        const events = yield* EventV2Bridge.Service
-        const info = yield* session.create({})
-
-        const messageID = MessageID.ascending()
-        yield* session.updateMessage({
-          id: messageID,
-          sessionID: info.id,
-          role: "user",
-          time: { created: Date.now() },
-          agent: "user",
-          model: { providerID: "test", modelID: "test" },
-          tools: {},
-          mode: "",
-        } as unknown as SessionV1.Info)
-
-        // Event subscribers receive readonly Schema.Type payloads; `SessionV1.Part`
-        // is the mutable domain type. Cast bridges the two — safe because the
-        // test only reads the value afterwards.
-        const received = yield* Deferred.make<SessionV1.Part>()
-        const unsub = yield* events.listen((event) => {
-          if (event.type === MessageV2.Event.PartUpdated.type)
-            Deferred.doneUnsafe(
-              received,
-              Effect.succeed((event.data as typeof MessageV2.Event.PartUpdated.data.Type).part as SessionV1.Part),
-            )
-          return Effect.void
-        })
-        yield* Effect.addFinalizer(() => unsub)
-
-        const tokens = {
-          total: 1500,
-          input: 500,
-          output: 800,
-          reasoning: 200,
-          cache: { read: 100, write: 50 },
-        }
-
-        const partInput = {
-          id: PartID.ascending(),
-          messageID,
-          sessionID: info.id,
-          type: "step-finish" as const,
-          reason: "stop",
-          cost: 0.005,
-          tokens,
-        }
-
-        yield* session.updatePart(partInput)
-        const receivedPart = yield* awaitDeferred(received, "timed out waiting for message.part.updated")
-
-        expect(receivedPart.type).toBe("step-finish")
-        const finish = receivedPart as SessionV1.StepFinishPart
-        expect(finish.tokens.input).toBe(500)
-        expect(finish.tokens.output).toBe(800)
-        expect(finish.tokens.reasoning).toBe(200)
-        expect(finish.tokens.total).toBe(1500)
-        expect(finish.tokens.cache.read).toBe(100)
-        expect(finish.tokens.cache.write).toBe(50)
-        expect(finish.cost).toBe(0.005)
-        expect(receivedPart).not.toBe(partInput)
-
-        yield* session.remove(info.id)
-      }),
-    { timeout: 30000 },
-  )
-})
-
-describe("Session", () => {
-  it.live("remove works without an instance", () =>
-    Effect.gen(function* () {
-      const session = yield* SessionNs.Service
-      const dir = yield* tmpdirScoped({ git: true })
-      const info = yield* provideInstance(dir)(session.create({ title: "remove-without-instance" }))
-
-      const removeExit = yield* remove(info.id).pipe(Effect.exit)
-      expect(Exit.isSuccess(removeExit)).toBe(true)
-
-      const getExit = yield* session.get(info.id).pipe(Effect.exit)
-      expect(Exit.isFailure(getExit)).toBe(true)
-    }),
-  )
-
-  it.instance("persists metadata and copies it on fork by default", () =>
-    Effect.gen(function* () {
-      const session = yield* SessionNs.Service
-      const meta = { source: "sdk", trace: { id: "abc" } }
-      const created = yield* Effect.acquireRelease(session.create({ title: "with-meta", metadata: meta }), (info) =>
-        session.remove(info.id).pipe(Effect.ignore),
-      )
-      const saved = yield* session.get(created.id)
-      const fork = yield* Effect.acquireRelease(session.fork({ sessionID: created.id }), (info) =>
-        session.remove(info.id).pipe(Effect.ignore),
-      )
-
-      expect(saved.metadata).toEqual(meta)
-      expect(fork.metadata).toEqual(meta)
-      expect(fork.metadata).not.toBe(meta)
-    }),
-  )
-
-  it.instance("omits metadata when not provided", () =>
-    Effect.gen(function* () {
-      const session = yield* SessionNs.Service
-      const created = yield* Effect.acquireRelease(session.create({ title: "empty-meta" }), (info) =>
-        session.remove(info.id).pipe(Effect.ignore),
-      )
-      const saved = yield* session.get(created.id)
-
-      expect(created.metadata).toBeUndefined()
-      expect(saved.metadata).toBeUndefined()
-    }),
-  )
-})