@neurocode-ai/core 1.18.8

package/test/patch.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, test } from "bun:test"
+import { Patch } from "@neurocode-ai/core/patch"
+
+describe("Patch", () => {
+  test("parses add, update, and delete hunks", () => {
+    expect(
+      Patch.parse(
+        "*** Begin Patch\n*** Add File: add.txt\n+added\n*** Update File: update.txt\n@@ section\n-old\n+new\n*** Delete File: delete.txt\n*** End Patch",
+      ),
+    ).toEqual([
+      { type: "add", path: "add.txt", contents: "added" },
+      {
+        type: "update",
+        path: "update.txt",
+        chunks: [{ oldLines: ["old"], newLines: ["new"], changeContext: "section", endOfFile: undefined }],
+        movePath: undefined,
+      },
+      { type: "delete", path: "delete.txt" },
+    ])
+  })
+
+  test("strips a heredoc wrapper", () => {
+    expect(Patch.parse("cat <<'EOF'\n*** Begin Patch\n*** Add File: add.txt\n+added\n*** End Patch\nEOF")).toEqual([
+      { type: "add", path: "add.txt", contents: "added" },
+    ])
+  })
+
+  test("derives fuzzy line updates while preserving BOM", () => {
+    const update = Patch.derive("update.txt", [{ oldLines: ["  old   "], newLines: ["new"] }], "\uFEFFold\n")
+    expect(update).toEqual({ content: "new\n", bom: true })
+    expect(Patch.joinBom(update.content, update.bom)).toBe("\uFEFFnew\n")
+  })
+
+  test("matches EOF-anchored chunks from the end", () => {
+    expect(
+      Patch.derive(
+        "update.txt",
+        [{ oldLines: ["marker", "end"], newLines: ["marker changed", "end"], endOfFile: true }],
+        "marker\nmiddle\nmarker\nend\n",
+      ).content,
+    ).toBe("marker\nmiddle\nmarker changed\nend\n")
+  })
+
+  test("parses the EOF marker inside update chunks", () => {
+    expect(
+      Patch.parse("*** Begin Patch\n*** Update File: update.txt\n@@\n-last\n+end\n*** End of File\n*** End Patch"),
+    ).toEqual([
+      {
+        type: "update",
+        path: "update.txt",
+        movePath: undefined,
+        chunks: [{ oldLines: ["last"], newLines: ["end"], changeContext: undefined, endOfFile: true }],
+      },
+    ])
+  })
+
+  test("rejects malformed hunk bodies", () => {
+    expect(() => Patch.parse("*** Begin Patch\n*** Add File: add.txt\nmissing plus\n*** End Patch")).toThrow(
+      "Invalid add file line",
+    )
+    expect(() => Patch.parse("*** Begin Patch\n*** Update File: update.txt\n*** End Patch")).toThrow(
+      "expected at least one @@ chunk",
+    )
+    expect(() => Patch.parse("*** Begin Patch\n*** Delete File: delete.txt\nunexpected body\n*** End Patch")).toThrow(
+      "Invalid patch line",
+    )
+  })
+})

package/test/permission.test.ts

@@ -0,0 +1,315 @@
+import { describe, expect } from "bun:test"
+import { Cause, Deferred, Effect, Fiber, Layer } from "effect"
+import { AgentV2 } from "@neurocode-ai/core/agent"
+import { Database } from "@neurocode-ai/core/database/database"
+import { AppNodeBuilder } from "@neurocode-ai/core/effect/app-node-builder"
+import { LayerNode } from "@neurocode-ai/core/effect/layer-node"
+import { EventV2 } from "@neurocode-ai/core/event"
+import { Location } from "@neurocode-ai/core/location"
+import { PermissionV2 } from "@neurocode-ai/core/permission"
+import { PermissionTable } from "@neurocode-ai/core/permission/sql"
+import { PermissionSaved } from "@neurocode-ai/core/permission/saved"
+import { Project } from "@neurocode-ai/core/project"
+import { ProjectTable } from "@neurocode-ai/core/project/sql"
+import { AbsolutePath } from "@neurocode-ai/core/schema"
+import { SessionV2 } from "@neurocode-ai/core/session"
+import { SessionTable } from "@neurocode-ai/core/session/sql"
+import { SessionStore } from "@neurocode-ai/core/session/store"
+import { eq } from "drizzle-orm"
+import { location } from "./fixture/location"
+import { testEffect } from "./lib/effect"
+
+const current = Layer.succeed(
+  Location.Service,
+  Location.Service.of(location({ directory: AbsolutePath.make("/project") })),
+)
+const it = testEffect(
+  AppNodeBuilder.build(
+    LayerNode.group([
+      Database.node,
+      EventV2.node,
+      SessionStore.node,
+      PermissionSaved.node,
+      AgentV2.node,
+      PermissionV2.node,
+    ]),
+    [[Location.node, current]],
+  ),
+)
+
+function setup(rules: PermissionV2.Ruleset = []) {
+  return Effect.gen(function* () {
+    const { db } = yield* Database.Service
+    yield* db
+      .insert(ProjectTable)
+      .values({ id: Project.ID.global, worktree: AbsolutePath.make("/project"), sandboxes: [] })
+      .onConflictDoNothing()
+      .run()
+      .pipe(Effect.orDie)
+    yield* db
+      .insert(SessionTable)
+      .values({
+        id: SessionV2.ID.make("ses_test"),
+        project_id: Project.ID.global,
+        slug: "test",
+        directory: "/project",
+        title: "test",
+        version: "test",
+        agent: "test",
+      })
+      .onConflictDoNothing()
+      .run()
+      .pipe(Effect.orDie)
+    yield* setRules(rules)
+  })
+}
+
+function setRules(rules: PermissionV2.Ruleset) {
+  return Effect.gen(function* () {
+    const agents = yield* AgentV2.Service
+    yield* agents.transform((editor) =>
+      editor.update(AgentV2.ID.make("test"), (agent) => {
+        agent.permissions = [...rules]
+      }),
+    )
+  })
+}
+
+function assertion(input: Partial<PermissionV2.AssertInput> = {}) {
+  return {
+    id: PermissionV2.ID.create("per_test"),
+    sessionID: SessionV2.ID.make("ses_test"),
+    action: "read",
+    resources: ["src/index.ts"],
+    ...input,
+  } satisfies PermissionV2.AssertInput
+}
+
+function waitForRequest() {
+  return Effect.gen(function* () {
+    const service = yield* PermissionV2.Service
+    const events = yield* EventV2.Service
+    const asked = yield* Deferred.make<PermissionV2.Request>()
+    const unsubscribe = yield* events.listen((event) =>
+      event.type === PermissionV2.Event.Asked.type
+        ? Deferred.succeed(asked, event.data as PermissionV2.Request).pipe(Effect.asVoid)
+        : Effect.void,
+    )
+    yield* Effect.addFinalizer(() => unsubscribe)
+    const fiber = yield* service.assert(assertion()).pipe(Effect.forkScoped)
+    const request = yield* Deferred.await(asked)
+    return { service, fiber, request }
+  })
+}
+
+describe("PermissionV2", () => {
+  it.effect("returns the evaluated effect and only queues prompts", () =>
+    Effect.gen(function* () {
+      yield* setup([{ action: "read", resource: "*", effect: "allow" }])
+      const service = yield* PermissionV2.Service
+      expect(yield* service.ask(assertion())).toEqual({ id: PermissionV2.ID.create("per_test"), effect: "allow" })
+      expect(yield* service.list()).toEqual([])
+      yield* setRules([{ action: "read", resource: "*", effect: "deny" }])
+      expect(yield* service.ask(assertion())).toEqual({ id: PermissionV2.ID.create("per_test"), effect: "deny" })
+      expect(yield* service.list()).toEqual([])
+      yield* setRules([])
+      expect(yield* service.ask(assertion())).toEqual({ id: PermissionV2.ID.create("per_test"), effect: "ask" })
+      expect(yield* service.get(PermissionV2.ID.create("per_test"))).toBeDefined()
+    }),
+  )
+
+  it.effect("evaluates against an explicit provider-turn agent", () =>
+    Effect.gen(function* () {
+      yield* setup([{ action: "read", resource: "*", effect: "allow" }])
+      const agents = yield* AgentV2.Service
+      yield* agents.transform((editor) =>
+        editor.update(AgentV2.ID.make("reviewer"), (agent) => {
+          agent.permissions.push({ action: "read", resource: "*", effect: "deny" })
+        }),
+      )
+      const service = yield* PermissionV2.Service
+
+      expect(yield* service.ask(assertion())).toMatchObject({ effect: "allow" })
+      expect(yield* service.ask(assertion({ agent: AgentV2.ID.make("reviewer") }))).toMatchObject({ effect: "deny" })
+      yield* agents.transform((editor) =>
+        editor.update(AgentV2.ID.make("reviewer"), (agent) => {
+          agent.permissions = []
+        }),
+      )
+      expect(yield* service.ask(assertion({ agent: AgentV2.ID.make("reviewer") }))).toMatchObject({ effect: "ask" })
+      expect(yield* service.get(PermissionV2.ID.create("per_test"))).not.toHaveProperty("agent")
+    }),
+  )
+
+  it.effect("allows and denies from explicit rules without asking", () =>
+    Effect.gen(function* () {
+      yield* setup([{ action: "read", resource: "*", effect: "allow" }])
+      const service = yield* PermissionV2.Service
+      yield* service.assert(assertion())
+      yield* setRules([{ action: "read", resource: "*", effect: "deny" }])
+      const blocked = yield* service.assert(assertion()).pipe(Effect.flip)
+      expect(blocked).toBeInstanceOf(PermissionV2.BlockedError)
+      expect(yield* service.list()).toEqual([])
+    }),
+  )
+
+  it.effect("allows managed output reads without granting external directory access", () =>
+    Effect.gen(function* () {
+      yield* setup([
+        { action: "*", resource: "*", effect: "deny" },
+        { action: "read", resource: "*", effect: "allow" },
+      ])
+      const service = yield* PermissionV2.Service
+
+      expect(yield* service.ask(assertion({ resources: ["tool_123"] }))).toMatchObject({ effect: "allow" })
+      expect(
+        yield* service.ask(assertion({ action: "external_directory", resources: ["/tmp/tool-output/*"] })),
+      ).toMatchObject({ effect: "deny" })
+    }),
+  )
+
+  it.effect("uses build permissions when the Session agent is omitted", () =>
+    Effect.gen(function* () {
+      yield* setup()
+      const { db } = yield* Database.Service
+      yield* db
+        .update(SessionTable)
+        .set({ agent: null })
+        .where(eq(SessionTable.id, SessionV2.ID.make("ses_test")))
+        .run()
+        .pipe(Effect.orDie)
+      const agents = yield* AgentV2.Service
+      yield* agents.transform((editor) =>
+        editor.update(AgentV2.ID.make("build"), (agent) => {
+          agent.permissions = [{ action: "todowrite", resource: "*", effect: "allow" }]
+        }),
+      )
+
+      const service = yield* PermissionV2.Service
+      expect(yield* service.ask(assertion({ action: "todowrite", resources: ["*"] }))).toEqual({
+        id: PermissionV2.ID.create("per_test"),
+        effect: "allow",
+      })
+      expect(yield* service.list()).toEqual([])
+    }),
+  )
+
+  it.effect("denies omitted-agent permissions when no primary default agent exists", () =>
+    Effect.gen(function* () {
+      yield* setup()
+      const { db } = yield* Database.Service
+      yield* db
+        .update(SessionTable)
+        .set({ agent: null })
+        .where(eq(SessionTable.id, SessionV2.ID.make("ses_test")))
+        .run()
+        .pipe(Effect.orDie)
+      const agents = yield* AgentV2.Service
+      yield* agents.transform((editor) => {
+        editor.remove(AgentV2.ID.make("test"))
+        editor.remove(AgentV2.ID.make("build"))
+      })
+
+      const service = yield* PermissionV2.Service
+      expect(yield* service.ask(assertion())).toEqual({ id: PermissionV2.ID.create("per_test"), effect: "deny" })
+      expect(yield* service.list()).toEqual([])
+    }),
+  )
+
+  it.effect("evaluates bash with the normal configured-rule semantics", () =>
+    Effect.gen(function* () {
+      yield* setup([{ action: "*", resource: "*", effect: "allow" }])
+      const service = yield* PermissionV2.Service
+      const bash = assertion({ action: "bash", resources: ["pwd"] })
+      expect(yield* service.ask(bash)).toEqual({ id: PermissionV2.ID.create("per_test"), effect: "allow" })
+
+      yield* setRules([])
+      expect(yield* service.ask(bash)).toEqual({ id: PermissionV2.ID.create("per_test"), effect: "ask" })
+      expect(yield* service.get(PermissionV2.ID.create("per_test"))).toBeDefined()
+    }),
+  )
+
+  it.effect("uses saved bash approvals while preserving configured deny precedence", () =>
+    Effect.gen(function* () {
+      yield* setup()
+      const saved = yield* PermissionSaved.Service
+      yield* saved.add({ projectID: Project.ID.global, action: "bash", resources: ["pwd"] })
+
+      const service = yield* PermissionV2.Service
+      expect(yield* service.ask(assertion({ action: "bash", resources: ["pwd"] }))).toEqual({
+        id: PermissionV2.ID.create("per_test"),
+        effect: "allow",
+      })
+      expect(yield* service.list()).toEqual([])
+
+      yield* setRules([{ action: "bash", resource: "*", effect: "deny" }])
+      expect(yield* service.ask(assertion({ action: "bash", resources: ["pwd"] }))).toEqual({
+        id: PermissionV2.ID.create("per_test"),
+        effect: "deny",
+      })
+    }),
+  )
+
+  it.effect("resolves an asked permission once", () =>
+    Effect.gen(function* () {
+      yield* setup()
+      const { service, fiber, request } = yield* waitForRequest()
+      expect(yield* service.list()).toEqual([request])
+      expect(yield* service.forSession(request.sessionID)).toEqual([request])
+      expect(yield* service.forSession(SessionV2.ID.make("ses_other"))).toEqual([])
+      expect(yield* service.get(request.id)).toEqual(request)
+      yield* service.reply({ requestID: request.id, reply: "once" })
+      yield* Fiber.join(fiber)
+      expect(yield* service.list()).toEqual([])
+      expect(yield* service.get(request.id)).toBeUndefined()
+    }),
+  )
+
+  it.effect("defects when an asked permission is declined", () =>
+    Effect.gen(function* () {
+      yield* setup()
+      const { service, fiber, request } = yield* waitForRequest()
+      yield* service.reply({ requestID: request.id, reply: "reject" })
+      const exit = yield* Fiber.await(fiber)
+
+      expect(exit._tag).toBe("Failure")
+      if (exit._tag === "Failure")
+        expect(
+          exit.cause.reasons.some(
+            (reason) => Cause.isDieReason(reason) && reason.defect instanceof PermissionV2.DeclinedError,
+          ),
+        ).toBe(true)
+      expect(yield* service.list()).toEqual([])
+    }),
+  )
+
+  it.effect("stores and removes saved resources for a project", () =>
+    Effect.gen(function* () {
+      yield* setup()
+      const service = yield* PermissionV2.Service
+      const asked = yield* Deferred.make<PermissionV2.Request>()
+      const events = yield* EventV2.Service
+      const unsubscribe = yield* events.listen((event) =>
+        event.type === PermissionV2.Event.Asked.type
+          ? Deferred.succeed(asked, event.data as PermissionV2.Request).pipe(Effect.asVoid)
+          : Effect.void,
+      )
+      yield* Effect.addFinalizer(() => unsubscribe)
+      const fiber = yield* service.assert(assertion({ save: ["src/*"] })).pipe(Effect.forkScoped)
+      const request = yield* Deferred.await(asked)
+      yield* service.reply({ requestID: request.id, reply: "always" })
+      yield* Fiber.join(fiber)
+
+      const { db } = yield* Database.Service
+      expect(
+        yield* db.select().from(PermissionTable).where(eq(PermissionTable.project_id, Project.ID.global)).all(),
+      ).toMatchObject([{ action: "read", resource: "src/*" }])
+      const saved = yield* PermissionSaved.Service
+      const id = (yield* saved.list())[0]!.id
+      expect(yield* saved.list()).toEqual([{ id, projectID: Project.ID.global, action: "read", resource: "src/*" }])
+      yield* service.assert(assertion({ id: PermissionV2.ID.create("per_next"), resources: ["src/next.ts"] }))
+      yield* saved.remove(id)
+      expect(yield* saved.list()).toEqual([])
+    }),
+  )
+})

package/test/plugin/command.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect } from "bun:test"
+import { Effect, Layer } from "effect"
+import { CommandV2 } from "@neurocode-ai/core/command"
+import { AppNodeBuilder } from "@neurocode-ai/core/effect/app-node-builder"
+import { Location } from "@neurocode-ai/core/location"
+import { CommandPlugin } from "@neurocode-ai/core/plugin/command"
+import { AbsolutePath } from "@neurocode-ai/core/schema"
+import { location } from "../fixture/location"
+import { testEffect } from "../lib/effect"
+import { host } from "./host"
+
+const directory = AbsolutePath.make("/repo/packages/app")
+const project = AbsolutePath.make("/repo")
+const locationLayer = Layer.succeed(
+  Location.Service,
+  Location.Service.of(location({ directory }, { projectDirectory: project })),
+)
+const it = testEffect(AppNodeBuilder.build(CommandV2.node, [[Location.node, locationLayer]]))
+
+describe("CommandPlugin.Plugin", () => {
+  it.effect("registers built-in init and review commands", () =>
+    Effect.gen(function* () {
+      const command = yield* CommandV2.Service
+      yield* CommandPlugin.Plugin.effect(
+        host({
+          command: { transform: command.transform, reload: command.reload },
+        }),
+      ).pipe(
+        Effect.provideService(
+          Location.Service,
+          Location.Service.of(location({ directory }, { projectDirectory: project })),
+        ),
+      )
+
+      expect(yield* command.get("init")).toMatchObject({
+        name: "init",
+        description: "guided AGENTS.md setup",
+      })
+      expect((yield* command.get("init"))?.template).toContain("`/repo`")
+      expect(yield* command.get("review")).toMatchObject({
+        name: "review",
+        description: "review changes [commit|branch|pr], defaults to uncommitted",
+        subtask: true,
+      })
+    }),
+  )
+})

package/test/plugin/fixture.ts

@@ -0,0 +1,52 @@
+import { AgentV2 } from "@neurocode-ai/core/agent"
+import { AISDK } from "@neurocode-ai/core/aisdk"
+import { Catalog } from "@neurocode-ai/core/catalog"
+import { CommandV2 } from "@neurocode-ai/core/command"
+import { Credential } from "@neurocode-ai/core/credential"
+import { AppNodeBuilder } from "@neurocode-ai/core/effect/app-node-builder"
+import { LayerNodePlatform } from "@neurocode-ai/core/effect/app-node-platform"
+import { LayerNode } from "@neurocode-ai/core/effect/layer-node"
+import { EventV2 } from "@neurocode-ai/core/event"
+import { FileSystem } from "@neurocode-ai/core/filesystem"
+import { FSUtil } from "@neurocode-ai/core/fs-util"
+import { Integration } from "@neurocode-ai/core/integration"
+import { Location } from "@neurocode-ai/core/location"
+import { Npm } from "@neurocode-ai/core/npm"
+import { PluginV2 } from "@neurocode-ai/core/plugin"
+import { Reference } from "@neurocode-ai/core/reference"
+import { SkillV2 } from "@neurocode-ai/core/skill"
+import { Effect, Layer } from "effect"
+import { tempLocationLayer } from "../fixture/location"
+
+const npmLayer = Layer.succeed(
+  Npm.Service,
+  Npm.Service.of({
+    add: () => Effect.succeed({ directory: "", entrypoint: undefined }),
+    install: () => Effect.void,
+    which: () => Effect.succeed(undefined),
+  }),
+)
+
+export const PluginTestLayer = AppNodeBuilder.build(
+  LayerNode.group([
+    FileSystem.node,
+    FSUtil.node,
+    Location.node,
+    Npm.node,
+    Credential.node,
+    EventV2.node,
+    LayerNodePlatform.httpClient,
+    PluginV2.node,
+    AgentV2.node,
+    AISDK.node,
+    Catalog.node,
+    CommandV2.node,
+    Integration.node,
+    Reference.node,
+    SkillV2.node,
+  ]),
+  [
+    [Location.node, tempLocationLayer],
+    [Npm.node, npmLayer],
+  ],
+)

package/test/plugin/fixtures/config-effect-plugin.ts

@@ -0,0 +1,15 @@
+import { define } from "@neurocode-ai/plugin/v2/effect"
+import { Effect } from "effect"
+
+export default define({
+  id: "config-effect-plugin",
+  effect: (ctx) =>
+    ctx.agent
+      .transform((agents) => {
+        agents.update("effect-configured", (agent) => {
+          agent.description = ctx.options.description
+          agent.mode = "subagent"
+        })
+      })
+      .pipe(Effect.asVoid),
+})

package/test/plugin/fixtures/config-promise-plugin.ts

@@ -0,0 +1,13 @@
+import { define } from "@neurocode-ai/plugin/v2/promise"
+
+export default define({
+  id: "config-promise-plugin",
+  setup: async (ctx) => {
+    await ctx.agent.transform((agents) => {
+      agents.update("configured", (agent) => {
+        agent.description = ctx.options.description
+        agent.mode = "subagent"
+      })
+    })
+  },
+})

package/test/plugin/fixtures/invalid-plugin.ts

@@ -0,0 +1 @@
+export default {}

package/test/plugin/fixtures/models-dev.json

@@ -0,0 +1,14 @@
+{
+  "acme": {
+    "id": "acme",
+    "name": "Acme",
+    "env": ["ACME_API_KEY"],
+    "models": {}
+  },
+  "local": {
+    "id": "local",
+    "name": "Local",
+    "env": [],
+    "models": {}
+  }
+}

package/test/plugin/fixtures/provider-factory.ts

@@ -0,0 +1,9 @@
+export function createFixtureProvider(options: Record<string, unknown>) {
+  const captured = Object.fromEntries(Object.entries(options))
+  return Object.assign((modelID: string) => ({ modelID, options: captured }), {
+    options: captured,
+    languageModel(modelID: string) {
+      return { modelID, options: captured }
+    },
+  })
+}