@neurocode-ai/core 1.18.8

package/test/location-layer.test.ts

@@ -0,0 +1,226 @@
+import fs from "fs/promises"
+import path from "path"
+import { describe, expect } from "bun:test"
+import { DateTime, Effect, Equal, Hash, Schema } from "effect"
+import { Tool } from "@neurocode-ai/core/tool/tool"
+import { define } from "@neurocode-ai/plugin/v2/effect"
+import { AgentV2 } from "@neurocode-ai/core/agent"
+import { Catalog } from "@neurocode-ai/core/catalog"
+import { AppNodeBuilder } from "@neurocode-ai/core/effect/app-node-builder"
+import { LayerNode } from "@neurocode-ai/core/effect/layer-node"
+import { LocationServiceMap } from "@neurocode-ai/core/location-services"
+import { Location } from "@neurocode-ai/core/location"
+import { PluginV2 } from "@neurocode-ai/core/plugin"
+import { ModelV2 } from "@neurocode-ai/core/model"
+import { ProjectV2 } from "@neurocode-ai/core/project"
+import { ProviderV2 } from "@neurocode-ai/core/provider"
+import { AbsolutePath } from "@neurocode-ai/core/schema"
+import { SessionV2 } from "@neurocode-ai/core/session"
+import { SessionRunnerModel } from "@neurocode-ai/core/session/runner/model"
+import { tmpdir } from "./fixture/tmpdir"
+import { testEffect } from "./lib/effect"
+import { toolDefinitions } from "./lib/tool"
+import { FSUtil } from "../src/fs-util"
+import { Credential } from "../src/credential"
+import { Database } from "../src/database/database"
+import { EventV2 } from "../src/event"
+import { Global } from "../src/global"
+import { ModelsDev } from "../src/models-dev"
+import { Npm } from "../src/npm"
+import { Project } from "../src/project"
+import { Reference } from "../src/reference"
+import { ToolRegistry } from "../src/tool/registry"
+import { ApplicationTools } from "../src/tool/application-tools"
+
+const it = testEffect(
+  AppNodeBuilder.build(LayerNode.group([ApplicationTools.node, Database.node, EventV2.node, LocationServiceMap.node])),
+)
+
+describe("LocationServiceMap", () => {
+  it.live("reuses cached services for constructed and decoded location refs", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((dir) =>
+        Effect.scoped(
+          Effect.gen(function* () {
+            const locations = yield* LocationServiceMap.Service
+            const directory = AbsolutePath.make(dir.path)
+            const constructed = Location.Ref.make({ directory })
+            const decoded = Schema.decodeUnknownSync(Location.Ref)({ directory })
+
+            expect(constructed).toEqual({ directory, workspaceID: undefined })
+            expect(decoded).toEqual(constructed)
+            expect(Equal.equals(constructed, decoded)).toBe(true)
+            expect(Hash.hash(constructed)).toBe(Hash.hash(decoded))
+            expect(yield* locations.contextEffect(constructed)).toBe(yield* locations.contextEffect(decoded))
+          }),
+        ),
+      ),
+    ),
+  )
+
+  it.live("isolates location state while sharing location policy with catalog", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => Promise.all([tmpdir(), tmpdir()])),
+      (dirs) => Effect.promise(() => Promise.all(dirs.map((dir) => dir[Symbol.asyncDispose]())).then(() => undefined)),
+    ).pipe(
+      Effect.flatMap(([blocked, allowed]) =>
+        Effect.gen(function* () {
+          yield* (yield* ApplicationTools.Service).register({
+            application_context: Tool.make({
+              description: "Read application context",
+              input: Schema.Struct({}),
+              output: Schema.Struct({ ok: Schema.Boolean }),
+              execute: () => Effect.succeed({ ok: true }),
+            }),
+          })
+          yield* Effect.promise(() =>
+            fs.writeFile(
+              path.join(blocked.path, "neurocode.json"),
+              JSON.stringify({
+                experimental: { policies: [{ effect: "deny", action: "provider.use", resource: "test" }] },
+              }),
+            ),
+          )
+
+          const update = (directory: string) =>
+            Effect.gen(function* () {
+              yield* Reference.Service
+              const catalog = yield* Catalog.Service
+              yield* catalog.transform((editor) => editor.provider.update(ProviderV2.ID.make("test"), () => {}))
+              return {
+                providers: yield* catalog.provider.all(),
+                tools: yield* toolDefinitions(yield* ToolRegistry.Service),
+              }
+            }).pipe(
+              Effect.scoped,
+              Effect.provide(
+                LocationServiceMap.Service.get(Location.Ref.make({ directory: AbsolutePath.make(directory) })),
+              ),
+            )
+
+          const blockedState = yield* update(blocked.path)
+          expect(blockedState.providers.some((provider) => provider.id === ProviderV2.ID.make("test"))).toBe(false)
+          expect(blockedState.tools.map((tool) => tool.name).sort()).toEqual([
+            "application_context",
+            "apply_patch",
+            "bash",
+            "edit",
+            "glob",
+            "grep",
+            "question",
+            "read",
+            "skill",
+            "todowrite",
+            "webfetch",
+            "websearch",
+            "write",
+          ])
+          const allowedState = yield* update(allowed.path)
+          expect(allowedState.providers.some((provider) => provider.id === ProviderV2.ID.make("test"))).toBe(true)
+          expect(allowedState.tools.map((tool) => tool.name).sort()).toEqual([
+            "application_context",
+            "apply_patch",
+            "bash",
+            "edit",
+            "glob",
+            "grep",
+            "question",
+            "read",
+            "skill",
+            "todowrite",
+            "webfetch",
+            "websearch",
+            "write",
+          ])
+        }),
+      ),
+    ),
+  )
+
+  it.live("rejects an unavailable selected model during location model resolution", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((dir) =>
+        Effect.gen(function* () {
+          const location = Location.Ref.make({ directory: AbsolutePath.make(dir.path) })
+          yield* Effect.promise(() =>
+            fs.writeFile(
+              path.join(dir.path, "neurocode.json"),
+              JSON.stringify({
+                providers: {
+                  unavailable: {
+                    name: "Unavailable",
+                    api: { type: "native", settings: {} },
+                    models: { chat: { disabled: true } },
+                  },
+                },
+              }),
+            ),
+          )
+          const failure = yield* SessionRunnerModel.Service.use((models) =>
+            models.resolve(
+              SessionV2.Info.make({
+                id: SessionV2.ID.make("ses_unavailable_model"),
+                projectID: ProjectV2.ID.global,
+                title: "test",
+                model: {
+                  id: ModelV2.ID.make("chat"),
+                  providerID: ProviderV2.ID.make("unavailable"),
+                },
+                cost: 0,
+                tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+                time: { created: DateTime.makeUnsafe(0), updated: DateTime.makeUnsafe(0) },
+                location,
+              }),
+            ),
+          ).pipe(Effect.provide(LocationServiceMap.Service.get(location)), Effect.flip)
+
+          expect(failure).toMatchObject({
+            _tag: "SessionRunnerModel.ModelUnavailableError",
+            providerID: "unavailable",
+            modelID: "chat",
+          })
+        }),
+      ),
+    ),
+  )
+
+  it.live("installs public plugins into a location", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((dir) =>
+        Effect.gen(function* () {
+          const plugins = yield* PluginV2.Service
+          const reviewer = define({
+            id: "reviewer",
+            effect: (ctx) =>
+              ctx.agent
+                .transform((agent) => {
+                  agent.update("reviewer", (item) => {
+                    item.description = "Reviews code"
+                    item.mode = "subagent"
+                  })
+                })
+                .pipe(Effect.asVoid),
+          })
+          yield* plugins.add(PluginV2.ID.make(reviewer.id), reviewer.effect)
+
+          expect(yield* (yield* AgentV2.Service).get(AgentV2.ID.make("reviewer"))).toMatchObject({
+            description: "Reviews code",
+            mode: "subagent",
+          })
+        }).pipe(
+          Effect.scoped,
+          Effect.provide(LocationServiceMap.Service.get(Location.Ref.make({ directory: AbsolutePath.make(dir.path) }))),
+        ),
+      ),
+    ),
+  )
+})

package/test/location-mutation.test.ts

@@ -0,0 +1,178 @@
+import fs from "fs/promises"
+import path from "path"
+import { describe, expect, test } from "bun:test"
+import { Effect, Layer, Schema } from "effect"
+import { LayerNode } from "@neurocode-ai/core/effect/layer-node"
+import { Location } from "@neurocode-ai/core/location"
+import { LocationMutation } from "@neurocode-ai/core/location-mutation"
+import { AbsolutePath } from "@neurocode-ai/core/schema"
+import { tmpdir } from "./fixture/tmpdir"
+import { location } from "./fixture/location"
+import { it } from "./lib/effect"
+
+function provide(directory: string) {
+  return Effect.provide(
+    LayerNode.compile(LocationMutation.node, [
+      [
+        Location.node,
+        Layer.succeed(Location.Service, Location.Service.of(location({ directory: AbsolutePath.make(directory) }))),
+      ],
+    ]),
+  )
+}
+
+function withTmp<A, E, R>(f: (directory: string) => Effect.Effect<A, E, R>) {
+  return Effect.acquireRelease(
+    Effect.promise(() => tmpdir()),
+    (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+  ).pipe(Effect.flatMap((tmp) => f(tmp.path)))
+}
+
+describe("LocationMutation", () => {
+  it.live("resolves an active relative existing file target", () =>
+    withTmp((directory) =>
+      Effect.gen(function* () {
+        const targetPath = path.join(directory, "hello.txt")
+        yield* Effect.promise(() => fs.writeFile(targetPath, "hello"))
+        const target = yield* (yield* LocationMutation.Service).resolve({ path: "hello.txt" })
+
+        expect(target).toMatchObject({
+          canonical: yield* Effect.promise(() => fs.realpath(targetPath)),
+          resource: "hello.txt",
+        })
+        expect(target.externalDirectory).toBeUndefined()
+      }).pipe(provide(directory)),
+    ),
+  )
+
+  it.live("resolves an active relative prospective file target", () =>
+    withTmp((directory) =>
+      Effect.gen(function* () {
+        yield* Effect.promise(() => fs.mkdir(path.join(directory, "src")))
+        const target = yield* (yield* LocationMutation.Service).resolve({ path: path.join("src", "new.txt") })
+        const root = yield* Effect.promise(() => fs.realpath(directory))
+
+        expect(target).toMatchObject({
+          canonical: path.join(root, "src", "new.txt"),
+          resource: "src/new.txt",
+        })
+      }).pipe(provide(directory)),
+    ),
+  )
+
+  it.live("rejects a relative lexical escape instead of promoting it to external authority", () =>
+    withTmp((directory) =>
+      Effect.gen(function* () {
+        const error = yield* Effect.flip((yield* LocationMutation.Service).resolve({ path: "../outside.txt" }))
+        expect(error).toMatchObject({ _tag: "LocationMutation.PathError", reason: "relative_escape" })
+      }).pipe(provide(directory)),
+    ),
+  )
+
+  it.live("rejects a prospective target below an escaping symlink ancestor", () =>
+    withTmp((directory) => {
+      const outside = `${directory}-outside`
+      return Effect.gen(function* () {
+        if (process.platform === "win32") return
+        yield* Effect.promise(async () => {
+          await fs.mkdir(outside)
+          await fs.symlink(outside, path.join(directory, "escape"))
+        })
+        const error = yield* Effect.flip(
+          (yield* LocationMutation.Service).resolve({ path: path.join("escape", "new.txt") }),
+        )
+        expect(error).toMatchObject({ _tag: "LocationMutation.PathError", reason: "location_escape" })
+        yield* Effect.promise(() => fs.rm(outside, { recursive: true, force: true }))
+      }).pipe(provide(directory))
+    }),
+  )
+
+  it.live("follows an in-location symlink using ordinary filesystem semantics", () =>
+    withTmp((directory) =>
+      Effect.gen(function* () {
+        if (process.platform === "win32") return
+        yield* Effect.promise(async () => {
+          await fs.mkdir(path.join(directory, "actual"))
+          await fs.symlink(path.join(directory, "actual"), path.join(directory, "linked"))
+        })
+
+        expect(yield* (yield* LocationMutation.Service).resolve({ path: "linked/new.txt" })).toMatchObject({
+          canonical: path.join(yield* Effect.promise(() => fs.realpath(directory)), "actual", "new.txt"),
+          resource: "actual/new.txt",
+        })
+      }).pipe(provide(directory)),
+    ),
+  )
+
+  it.live("accepts an explicit absolute in-location target without external approval", () =>
+    withTmp((directory) =>
+      Effect.gen(function* () {
+        const targetPath = path.join(directory, "new.txt")
+        const target = yield* (yield* LocationMutation.Service).resolve({ path: targetPath })
+        expect(target).toMatchObject({
+          canonical: path.join(yield* Effect.promise(() => fs.realpath(directory)), "new.txt"),
+          resource: "new.txt",
+        })
+        expect(target.externalDirectory).toBeUndefined()
+      }).pipe(provide(directory)),
+    ),
+  )
+
+  it.live("requires external-directory authorization for an explicit external absolute target", () =>
+    withTmp((directory) =>
+      withTmp((outside) =>
+        Effect.gen(function* () {
+          const targetPath = path.join(outside, "new.txt")
+          const target = yield* (yield* LocationMutation.Service).resolve({ path: targetPath })
+          const root = yield* Effect.promise(() => fs.realpath(outside))
+          expect(target).toMatchObject({
+            canonical: path.join(root, "new.txt"),
+            resource: path.join(root, "new.txt").replaceAll("\\", "/"),
+          })
+          expect(target.externalDirectory).toMatchObject({
+            directory: root,
+            resource: path.join(root, "*").replaceAll("\\", "/"),
+          })
+        }).pipe(provide(directory)),
+      ),
+    ),
+  )
+
+  it.live("resolves an existing external file target", () =>
+    withTmp((directory) =>
+      withTmp((outside) =>
+        Effect.gen(function* () {
+          const targetPath = path.join(outside, "existing.txt")
+          yield* Effect.promise(() => fs.writeFile(targetPath, "existing"))
+          const target = yield* (yield* LocationMutation.Service).resolve({ path: targetPath })
+          const root = yield* Effect.promise(() => fs.realpath(outside))
+          expect(target).toMatchObject({ canonical: path.join(root, "existing.txt") })
+          expect(target.externalDirectory?.directory).toBe(root)
+        }).pipe(provide(directory)),
+      ),
+    ),
+  )
+
+  it.live("anchors prospective external descendants at their stable existing directory", () =>
+    withTmp((directory) =>
+      withTmp((outside) =>
+        Effect.gen(function* () {
+          const targetPath = path.join(outside, "new", "nested", "file.txt")
+          const target = yield* (yield* LocationMutation.Service).resolve({ path: targetPath })
+          const root = yield* Effect.promise(() => fs.realpath(outside))
+          expect(target.externalDirectory).toMatchObject({
+            directory: root,
+            resource: path.join(root, "*").replaceAll("\\", "/"),
+          })
+        }).pipe(provide(directory)),
+      ),
+    ),
+  )
+
+  test("ignores unknown mutation input fields", () => {
+    expect(Object.keys(LocationMutation.ResolveInput.fields)).toEqual(["path", "kind"])
+    expect(Schema.decodeUnknownSync(LocationMutation.ResolveInput)({ path: "README.md", reference: "docs" })).toEqual({
+      path: "README.md",
+    })
+  })
+})

package/test/location.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect } from "bun:test"
+import { Effect, Layer } from "effect"
+import { AppNodeBuilder } from "@neurocode-ai/core/effect/app-node-builder"
+import { Location } from "@neurocode-ai/core/location"
+import { Project } from "@neurocode-ai/core/project"
+import { AbsolutePath } from "@neurocode-ai/core/schema"
+import { WorkspaceV2 } from "@neurocode-ai/core/workspace"
+import { testEffect } from "./lib/effect"
+
+const workspaceID = WorkspaceV2.ID.make("wrk_test")
+const ref = { directory: AbsolutePath.make("/repo/packages/app"), workspaceID }
+const projectLayer = Layer.succeed(
+  Project.Service,
+  Project.Service.of({
+    directories: () => Effect.succeed([]),
+    resolve: () =>
+      Effect.succeed({
+        id: Project.ID.make("project"),
+        directory: AbsolutePath.make("/repo"),
+        vcs: { type: "git", store: AbsolutePath.make("/repo/.git") },
+      }),
+    commit: () => Effect.void,
+  }),
+)
+const it = testEffect(AppNodeBuilder.build(Location.boundNode(ref), [[Project.node, projectLayer]]))
+
+describe("Location", () => {
+  it.effect("resolves the current project and vcs information", () =>
+    Effect.gen(function* () {
+      const location = yield* Location.Service
+
+      expect(location.directory).toBe(AbsolutePath.make("/repo/packages/app"))
+      expect(location.workspaceID).toBe(workspaceID)
+      expect(location.project.id).toBe(Project.ID.make("project"))
+      expect(location.project.directory).toBe(AbsolutePath.make("/repo"))
+      expect(location.vcs).toEqual({
+        type: "git",
+        store: AbsolutePath.make("/repo/.git"),
+      })
+    }),
+  )
+})

package/test/model.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, test } from "bun:test"
+import { Schema } from "effect"
+import { ModelV2 } from "@neurocode-ai/core/model"
+import { ProviderV2 } from "@neurocode-ai/core/provider"
+
+const decode = Schema.decodeUnknownSync(ModelV2.Ref)
+
+describe("ModelV2.Ref", () => {
+  test("accepts a model selection without a variant", () => {
+    expect(decode({ id: "claude-sonnet", providerID: "anthropic" })).toEqual({
+      id: ModelV2.ID.make("claude-sonnet"),
+      providerID: ProviderV2.ID.make("anthropic"),
+    })
+  })
+
+  test("preserves an explicit model variant", () => {
+    expect(decode({ id: "claude-sonnet", providerID: "anthropic", variant: "high" })).toEqual({
+      id: ModelV2.ID.make("claude-sonnet"),
+      providerID: ProviderV2.ID.make("anthropic"),
+      variant: ModelV2.VariantID.make("high"),
+    })
+  })
+})