@neurocode-ai/core 1.18.8

package/src/tool/edit.ts

@@ -0,0 +1,223 @@
+/**
+ * Model-facing V2 exact-edit leaf. Relative paths resolve within the active
+ * Location. Absolute paths inside that Location are accepted, while explicit
+ * absolute external paths retain mutation capability through a separate
+ * external_directory approval before edit approval.
+ */
+export * as EditTool from "./edit"
+
+import { ToolFailure } from "@neurocode-ai/llm"
+import { FileDiff } from "@neurocode-ai/schema/file-diff"
+import { createTwoFilesPatch, diffLines } from "diff"
+import { Effect, Layer, Schema } from "effect"
+import { makeLocationNode } from "../effect/app-node"
+import { FileMutation } from "../file-mutation"
+import { FSUtil } from "../fs-util"
+import { LocationMutation } from "../location-mutation"
+import { PermissionV2 } from "../permission"
+import { ToolRegistry } from "./registry"
+import { Tool } from "./tool"
+import { Tools } from "./tools"
+
+export const name = "edit"
+
+export const Input = Schema.Struct({
+  path: Schema.String.annotate({
+    description:
+      "File path to edit. Relative paths resolve within the active Location. Absolute paths inside that Location are accepted; external absolute paths require external_directory approval.",
+  }),
+  oldString: Schema.String.annotate({ description: "Exact text to replace" }),
+  newString: Schema.String.annotate({ description: "Replacement text, which must differ from oldString" }),
+  replaceAll: Schema.Boolean.pipe(Schema.optional).annotate({
+    description: "Replace all exact occurrences of oldString (default false)",
+  }),
+})
+
+export const Output = Schema.Struct({
+  files: Schema.Array(FileDiff.Info),
+  replacements: Schema.Number,
+})
+export type Output = typeof Output.Type
+
+const normalizeLineEndings = (text: string) => text.replaceAll("\r\n", "\n")
+const detectLineEnding = (text: string): "\n" | "\r\n" => (text.includes("\r\n") ? "\r\n" : "\n")
+const convertToLineEnding = (text: string, ending: "\n" | "\r\n") =>
+  ending === "\n" ? normalizeLineEndings(text) : normalizeLineEndings(text).replaceAll("\n", "\r\n")
+
+const splitBom = (text: string) =>
+  text.startsWith("\uFEFF") ? { bom: true, text: text.slice(1) } : { bom: false, text }
+const joinBom = (text: string, bom: boolean) => (bom ? `\uFEFF${text}` : text)
+const decodeUtf8 = (content: Uint8Array) => {
+  const bom = content[0] === 0xef && content[1] === 0xbb && content[2] === 0xbf
+  return { bom, content, text: new TextDecoder().decode(bom ? content.slice(3) : content) }
+}
+
+const countOccurrences = (content: string, search: string) => {
+  if (search === "") return content.length + 1
+  let count = 0
+  let offset = 0
+  while ((offset = content.indexOf(search, offset)) !== -1) {
+    count++
+    offset += search.length
+  }
+  return count
+}
+
+const previewLines = (value: string, prefix: "+" | "-") => {
+  const lines = normalizeLineEndings(value).split("\n")
+  const shown = lines.slice(0, 6).map((line) => `${prefix}${line.length > 240 ? `${line.slice(0, 240)}...` : line}`)
+  if (lines.length > shown.length) shown.push(`${prefix}...`)
+  return shown
+}
+
+export const toModelOutput = (output: Output, oldString: string, newString: string) =>
+  [
+    `Edited file successfully: ${output.files[0]?.file}`,
+    `Replacements: ${output.replacements}`,
+    "```diff",
+    ...previewLines(oldString, "-"),
+    ...previewLines(newString, "+"),
+    "```",
+  ].join("\n")
+
+/** Deferred V2 edit behavior and UX integrations remain visible at the model-facing seam. */
+// TODO: Port V1 fuzzy correction strategies only after exact-edit behavior is established: line-trimmed matching, block-anchor fallback, indentation correction, and similarity-threshold review.
+// TODO: Add formatter integration after V2 formatter runtime exists.
+// TODO: Publish watcher/file-edit events after V2 watcher integration exists.
+// TODO: Add snapshots / undo after design exists.
+// TODO: Add LSP notification and diagnostics after V2 LSP runtime exists.
+
+const layer = Layer.effectDiscard(
+  Effect.gen(function* () {
+    const tools = yield* Tools.Service
+    const mutation = yield* LocationMutation.Service
+    const files = yield* FileMutation.Service
+    const fs = yield* FSUtil.Service
+    const permission = yield* PermissionV2.Service
+
+    yield* tools
+      .register({
+        [name]: Tool.withPermission(
+          Tool.make({
+            description:
+              "Replace exact text in one file. Relative paths resolve within the active Location. Absolute paths inside the Location are accepted. Explicit external absolute paths require external_directory approval before edit approval.",
+            input: Input,
+            output: Output,
+            toModelOutput: ({ input, output }) => [
+              { type: "text", text: toModelOutput(output, input.oldString, input.newString) },
+            ],
+            execute: (input, context) => {
+              const unableToEdit = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+                effect.pipe(
+                  Effect.mapError((error) =>
+                    error instanceof FileMutation.StaleContentError
+                      ? new ToolFailure({
+                          message: "File changed after permission approval. Read it again before editing.",
+                        })
+                      : new ToolFailure({ message: `Unable to edit ${input.path}` }),
+                  ),
+                )
+
+              return Effect.gen(function* () {
+                const permissionSource = {
+                  type: "tool" as const,
+                  messageID: context.assistantMessageID,
+                  callID: context.toolCallID,
+                }
+                if (input.oldString === input.newString) {
+                  return yield* new ToolFailure({
+                    message: "No changes to apply: oldString and newString are identical.",
+                  })
+                }
+                if (input.oldString === "") {
+                  return yield* new ToolFailure({
+                    message: "oldString must not be empty. Use write to create or overwrite a file.",
+                  })
+                }
+
+                const target = yield* unableToEdit(mutation.resolve({ path: input.path, kind: "file" }))
+                const external = target.externalDirectory
+                if (external) {
+                  yield* unableToEdit(
+                    permission.assert({
+                      ...LocationMutation.externalDirectoryPermission(external),
+                      sessionID: context.sessionID,
+                      agent: context.agent,
+                      source: permissionSource,
+                    }),
+                  )
+                }
+
+                yield* unableToEdit(
+                  permission.assert({
+                    action: "edit",
+                    resources: [target.resource],
+                    save: ["*"],
+                    sessionID: context.sessionID,
+                    agent: context.agent,
+                    source: permissionSource,
+                  }),
+                )
+                const source = decodeUtf8(yield* unableToEdit(fs.readFile(target.canonical)))
+                const ending = detectLineEnding(source.text)
+                const oldString = convertToLineEnding(input.oldString, ending)
+                const newString = convertToLineEnding(input.newString, ending)
+                const replacements = countOccurrences(source.text, oldString)
+                if (replacements === 0) {
+                  return yield* new ToolFailure({
+                    message:
+                      "Could not find oldString in the file. It must match exactly, including whitespace and indentation.",
+                  })
+                }
+                if (replacements > 1 && input.replaceAll !== true) {
+                  return yield* new ToolFailure({
+                    message:
+                      "Found multiple exact matches for oldString. Provide more surrounding context or set replaceAll to true.",
+                  })
+                }
+
+                const replaced =
+                  input.replaceAll === true
+                    ? source.text.replaceAll(oldString, newString)
+                    : source.text.replace(oldString, newString)
+                const counts = diffLines(source.text, replaced).reduce(
+                  (result, item) => ({
+                    additions: result.additions + (item.added ? (item.count ?? 0) : 0),
+                    deletions: result.deletions + (item.removed ? (item.count ?? 0) : 0),
+                  }),
+                  { additions: 0, deletions: 0 },
+                )
+                const next = splitBom(replaced)
+                const result = yield* unableToEdit(
+                  files.writeIfUnchanged({
+                    target,
+                    expected: source.content,
+                    content: joinBom(next.text, source.bom || next.bom),
+                  }),
+                )
+                return {
+                  files: [
+                    {
+                      file: result.resource,
+                      patch: createTwoFilesPatch(result.resource, result.resource, source.text, replaced),
+                      status: "modified" as const,
+                      ...counts,
+                    },
+                  ],
+                  replacements,
+                } satisfies Output
+              })
+            },
+          }),
+          "edit",
+        ),
+      })
+      .pipe(Effect.orDie)
+  }),
+)
+
+export const node = makeLocationNode({
+  name: "tool/edit",
+  layer,
+  deps: [ToolRegistry.node, LocationMutation.node, FileMutation.node, FSUtil.node, PermissionV2.node],
+})

package/src/tool/glob.ts

@@ -0,0 +1,105 @@
+export * as GlobTool from "./glob"
+
+import { ToolFailure } from "@neurocode-ai/llm"
+import { Effect, Layer, Schema } from "effect"
+import path from "path"
+import { makeLocationNode } from "../effect/app-node"
+import { FileSystem } from "../filesystem"
+import { Location } from "../location"
+import { Ripgrep } from "../ripgrep"
+import { RelativePath } from "../schema"
+import { PermissionV2 } from "../permission"
+import { ToolRegistry } from "./registry"
+import { Tool } from "./tool"
+import { Tools } from "./tools"
+
+export const name = "glob"
+
+export const Input = Schema.Struct({
+  pattern: FileSystem.GlobInput.fields.pattern.annotate({ description: "Glob pattern to match files against" }),
+  path: RelativePath.pipe(Schema.optional).annotate({
+    description: "Relative directory to search. Defaults to the active Location.",
+  }),
+  limit: FileSystem.GlobInput.fields.limit.annotate({
+    description: "Maximum results to return",
+  }),
+})
+
+export const Output = Schema.Array(FileSystem.Entry)
+type ModelOutput = typeof Output.Encoded
+
+/** Format raw search results into the concise line-oriented output models expect. */
+export const toModelOutput = (output: ModelOutput) => {
+  const lines = output.length === 0 ? ["No files found"] : output.map((item) => item.path)
+  return lines.join("\n")
+}
+
+/** Glob leaf that defaults its filesystem root to the active Location. */
+const layer = Layer.effectDiscard(
+  Effect.gen(function* () {
+    const tools = yield* Tools.Service
+    const ripgrep = yield* Ripgrep.Service
+    const location = yield* Location.Service
+    const permission = yield* PermissionV2.Service
+
+    yield* tools
+      .register({
+        [name]: Tool.make({
+          description:
+            "Find files by glob pattern within the active Location. Returns concise relative file resources. Use a relative path to narrow the search and limit to bound the result count.",
+          input: Input,
+          output: Output,
+          toModelOutput: ({ output }) => [
+            {
+              type: "text",
+              text: toModelOutput(
+                output.map((entry) => ({ ...entry, path: path.resolve(location.directory, entry.path) })),
+              ),
+            },
+          ],
+          execute: (input, context) =>
+            Effect.gen(function* () {
+              yield* permission.assert({
+                action: name,
+                resources: [input.pattern],
+                save: ["*"],
+                metadata: {
+                  root: input.path ?? ".",
+                  path: input.path,
+                  limit: input.limit,
+                },
+                sessionID: context.sessionID,
+                agent: context.agent,
+                source: { type: "tool", messageID: context.assistantMessageID, callID: context.toolCallID },
+              })
+              const cwd = path.resolve(location.directory, input.path ?? ".")
+              return yield* ripgrep
+                .glob({
+                  cwd,
+                  pattern: input.pattern,
+                  limit: input.limit ?? Number.MAX_SAFE_INTEGER,
+                })
+                .pipe(
+                  Effect.map((result) =>
+                    result.map((entry) =>
+                      FileSystem.Entry.make({
+                        ...entry,
+                        path: RelativePath.make(path.relative(location.directory, path.resolve(cwd, entry.path))),
+                      }),
+                    ),
+                  ),
+                )
+            }).pipe(
+              Effect.mapError(() => new ToolFailure({ message: `Unable to find files matching ${input.pattern}` })),
+            ),
+        }),
+      })
+      .pipe(Effect.orDie)
+  }),
+)
+
+export const node = makeLocationNode({
+  name: "tool/glob",
+  layer,
+  deps: [ToolRegistry.node, Ripgrep.node, Location.node, PermissionV2.node],
+})

package/src/tool/grep.ts

@@ -0,0 +1,137 @@
+export * as GrepTool from "./grep"
+
+import { ToolFailure } from "@neurocode-ai/llm"
+import { Effect, Layer, Schema } from "effect"
+import path from "path"
+import { makeLocationNode } from "../effect/app-node"
+import { FileSystem } from "../filesystem"
+import { FSUtil } from "../fs-util"
+import { Location } from "../location"
+import { PermissionV2 } from "../permission"
+import { Ripgrep } from "../ripgrep"
+import { RelativePath } from "../schema"
+import { ToolRegistry } from "./registry"
+import { Tool } from "./tool"
+import { Tools } from "./tools"
+
+export const name = "grep"
+
+export const Input = Schema.Struct({
+  pattern: FileSystem.GrepInput.fields.pattern.annotate({
+    description: "Regex pattern to search for in file contents",
+  }),
+  path: RelativePath.pipe(Schema.optional).annotate({
+    description: "Relative directory to search. Defaults to the active Location.",
+  }),
+  include: FileSystem.GrepInput.fields.include.annotate({
+    description: 'File glob to include in the search (for example, "*.js" or "*.{ts,tsx}")',
+  }),
+  limit: FileSystem.GrepInput.fields.limit.annotate({
+    description: "Maximum matches to return",
+  }),
+})
+
+export const Output = Schema.Array(FileSystem.Match)
+type ModelOutput = typeof Output.Encoded
+
+/** Format raw search matches into the familiar concise model output. */
+export const toModelOutput = (output: ModelOutput) => {
+  const lines = output.length === 0 ? ["No files found"] : [`Found ${output.length} matches`]
+  let current = ""
+  for (const match of output) {
+    if (current !== match.entry.path) {
+      if (current) lines.push("")
+      current = match.entry.path
+      lines.push(`${match.entry.path}:`)
+    }
+    lines.push(`  Line ${match.line}: ${match.text}`)
+  }
+  return lines.join("\n")
+}
+
+/** Grep leaf that defaults its filesystem root to the active Location. */
+const layer = Layer.effectDiscard(
+  Effect.gen(function* () {
+    const tools = yield* Tools.Service
+    const fs = yield* FSUtil.Service
+    const ripgrep = yield* Ripgrep.Service
+    const location = yield* Location.Service
+    const permission = yield* PermissionV2.Service
+
+    yield* tools
+      .register({
+        [name]: Tool.make({
+          description:
+            "Search file contents by regular expression within the active Location or an absolute managed tool-output file. Use a path to narrow the search, include to filter files by glob, and limit to bound the match count. Returns concise file resources, line numbers, and bounded line previews.",
+          input: Input,
+          output: Output,
+          toModelOutput: ({ output }) => [
+            {
+              type: "text",
+              text: toModelOutput(
+                output.map((match) => ({
+                  ...match,
+                  entry: { ...match.entry, path: path.resolve(location.directory, match.entry.path) },
+                })),
+              ),
+            },
+          ],
+          execute: (input, context) =>
+            Effect.gen(function* () {
+              yield* permission.assert({
+                action: name,
+                resources: [input.pattern],
+                save: ["*"],
+                metadata: {
+                  root: ".",
+                  path: input.path,
+                  include: input.include,
+                  limit: input.limit,
+                },
+                sessionID: context.sessionID,
+                agent: context.agent,
+                source: { type: "tool", messageID: context.assistantMessageID, callID: context.toolCallID },
+              })
+              const target = path.resolve(location.directory, input.path ?? ".")
+              const info = yield* fs.stat(target).pipe(Effect.catch(() => Effect.succeed(undefined)))
+              return yield* ripgrep
+                .grep({
+                  cwd: info?.type === "Directory" ? target : path.dirname(target),
+                  pattern: input.pattern,
+                  file: info?.type === "File" ? path.basename(target) : undefined,
+                  include: input.include,
+                  limit: input.limit ?? Number.MAX_SAFE_INTEGER,
+                })
+                .pipe(
+                  Effect.map((result) =>
+                    result.map((match) =>
+                      FileSystem.Match.make({
+                        ...match,
+                        entry: FileSystem.Entry.make({
+                          ...match.entry,
+                          path: RelativePath.make(
+                            path.relative(
+                              location.directory,
+                              path.resolve(
+                                info?.type === "Directory" ? target : path.dirname(target),
+                                match.entry.path,
+                              ),
+                            ),
+                          ),
+                        }),
+                      }),
+                    ),
+                  ),
+                )
+            }).pipe(Effect.mapError(() => new ToolFailure({ message: `Unable to grep for ${input.pattern}` }))),
+        }),
+      })
+      .pipe(Effect.orDie)
+  }),
+)
+
+export const node = makeLocationNode({
+  name: "tool/grep",
+  layer,
+  deps: [ToolRegistry.node, FSUtil.node, Ripgrep.node, Location.node, PermissionV2.node],
+})

package/src/tool/http-body.ts

@@ -0,0 +1,30 @@
+import { Effect, Stream } from "effect"
+import { HttpClientResponse } from "effect/unstable/http"
+
+export const collectBoundedResponseBody = (
+  response: HttpClientResponse.HttpClientResponse,
+  maximumBytes: number,
+  tooLarge: () => Error,
+) =>
+  Effect.gen(function* () {
+    const contentLength = response.headers["content-length"]
+    const parsedSize = contentLength ? Number.parseInt(contentLength, 10) : undefined
+    const declaredSize =
+      parsedSize !== undefined && Number.isSafeInteger(parsedSize) && parsedSize >= 0 ? parsedSize : undefined
+    if (declaredSize !== undefined && declaredSize > maximumBytes) return yield* Effect.fail(tooLarge())
+    let body = Buffer.allocUnsafe(Math.min(maximumBytes, declaredSize || 64 * 1024))
+    let size = 0
+    yield* Stream.runForEach(response.stream, (chunk) => {
+      if (chunk.byteLength === 0) return Effect.void
+      if (size + chunk.byteLength > maximumBytes) return Effect.fail(tooLarge())
+      if (size + chunk.byteLength > body.byteLength) {
+        const grown = Buffer.allocUnsafe(Math.min(maximumBytes, Math.max(size + chunk.byteLength, body.byteLength * 2)))
+        body.copy(grown, 0, 0, size)
+        body = grown
+      }
+      body.set(chunk, size)
+      size += chunk.byteLength
+      return Effect.void
+    })
+    return body.subarray(0, size)
+  })

package/src/tool/question.ts

@@ -0,0 +1,94 @@
+export * as QuestionTool from "./question"
+
+import { ToolFailure } from "@neurocode-ai/llm"
+import { Effect, Layer, Schema } from "effect"
+import { makeLocationNode } from "../effect/app-node"
+import { PermissionV2 } from "../permission"
+import { QuestionV2 } from "../question"
+import { ToolRegistry } from "./registry"
+import { Tool } from "./tool"
+import { Tools } from "./tools"
+
+export const name = "question"
+
+export const description = `Use this tool when you need to ask the user questions during execution. This allows you to:
+1. Gather user preferences or requirements
+2. Clarify ambiguous instructions
+3. Get decisions on implementation choices as you work
+4. Offer choices to the user about what direction to take.
+
+Usage notes:
+- When \`custom\` is enabled (default), a "Type your own answer" option is added automatically; don't include "Other" or catch-all options
+- Answers are returned as arrays of labels; set \`multiple: true\` to allow selecting more than one
+- If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label`
+
+export const Input = Schema.Struct({
+  questions: Schema.Array(QuestionV2.Prompt).annotate({ description: "Questions to ask" }),
+})
+
+export const Output = Schema.Struct({
+  answers: Schema.Array(QuestionV2.Answer),
+})
+export type Output = typeof Output.Type
+
+export const toModelOutput = (
+  questions: ReadonlyArray<QuestionV2.Prompt>,
+  answers: ReadonlyArray<QuestionV2.Answer>,
+) => {
+  const formatted = questions
+    .map(
+      (question, index) =>
+        `"${question.question}"="${answers[index]?.length ? answers[index].join(", ") : "Unanswered"}"`,
+    )
+    .join(", ")
+  return `User has answered your questions: ${formatted}. You can now continue with the user's answers in mind.`
+}
+
+const layer = Layer.effectDiscard(
+  Effect.gen(function* () {
+    const tools = yield* Tools.Service
+    const question = yield* QuestionV2.Service
+    const permission = yield* PermissionV2.Service
+
+    yield* tools
+      .register({
+        [name]: Tool.make({
+          description,
+          input: Input,
+          output: Output,
+          toModelOutput: ({ input, output }) => [
+            { type: "text", text: toModelOutput(input.questions, output.answers) },
+          ],
+          execute: (input, context) =>
+            permission
+              .assert({
+                action: "question",
+                resources: ["*"],
+                sessionID: context.sessionID,
+                agent: context.agent,
+                source: { type: "tool", messageID: context.assistantMessageID, callID: context.toolCallID },
+              })
+              .pipe(
+                Effect.mapError(() => new ToolFailure({ message: "Permission denied: question" })),
+                Effect.andThen(
+                  question
+                    .ask({
+                      sessionID: context.sessionID,
+                      questions: input.questions,
+                      tool: { messageID: context.assistantMessageID, callID: context.toolCallID },
+                    })
+                    .pipe(Effect.orDie),
+                ),
+                Effect.map((answers) => ({ answers })),
+              ),
+        }),
+      })
+      .pipe(Effect.orDie)
+  }),
+)
+
+export const node = makeLocationNode({
+  name: "tool/question",
+  layer,
+  deps: [ToolRegistry.node, PermissionV2.node, QuestionV2.node],
+})