clanka 0.0.1

package/src/AgentTools.ts

@@ -0,0 +1,507 @@
+/**
+ * @since 1.0.0
+ */
+import {
+  Array,
+  Data,
+  Deferred,
+  Effect,
+  FileSystem,
+  Path,
+  pipe,
+  Schema,
+  ServiceMap,
+  Stream,
+} from "effect"
+import { Tool, Toolkit } from "effect/unstable/ai"
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
+import * as Glob from "glob"
+import * as Rg from "@vscode/ripgrep"
+import { parsePatch, patchChunks } from "./ApplyPatch.ts"
+
+/**
+ * @since 1.0.0
+ * @category Context
+ */
+export class CurrentDirectory extends ServiceMap.Service<
+  CurrentDirectory,
+  string
+>()("clanka/AgentTools/CurrentDirectory") {}
+
+/**
+ * @since 1.0.0
+ * @category Context
+ */
+export class TaskCompleteDeferred extends ServiceMap.Service<
+  TaskCompleteDeferred,
+  Deferred.Deferred<string>
+>()("clanka/AgentTools/TaskCompleteDeferred") {}
+
+/**
+ * @since 1.0.0
+ * @category Context
+ */
+export class SubagentContext extends ServiceMap.Service<
+  SubagentContext,
+  {
+    spawn(options: { readonly prompt: string }): Effect.Effect<string>
+  }
+>()("clanka/AgentTools/SubagentContext") {}
+
+/**
+ * @since 1.0.0
+ * @category Context
+ */
+export const makeContextNoop = (cwd?: string) =>
+  SubagentContext.serviceMap({
+    spawn: () => Effect.die("Not implemented"),
+  }).pipe(
+    ServiceMap.add(CurrentDirectory, cwd ?? "/"),
+    ServiceMap.add(TaskCompleteDeferred, Deferred.makeUnsafe()),
+  )
+
+/**
+ * @since 1.0.0
+ * @category Toolkit
+ */
+export const AgentTools = Toolkit.make(
+  Tool.make("readFile", {
+    description:
+      "Read a file and optionally filter the lines to return. Returns null if the file doesn't exist.",
+    parameters: Schema.Struct({
+      path: Schema.String,
+      startLine: Schema.optional(Schema.Number),
+      endLine: Schema.optional(Schema.Number),
+    }),
+    success: Schema.NullOr(Schema.String),
+    dependencies: [CurrentDirectory],
+  }),
+  Tool.make("createFile", {
+    description:
+      "Write content to a file, creating parent directories if needed.",
+    parameters: Schema.Struct({
+      path: Schema.String,
+      content: Schema.String,
+    }),
+    dependencies: [CurrentDirectory],
+  }),
+  Tool.make("applyPatch", {
+    description: "Apply a wrapped patch with Add/Delete/Update sections.",
+    parameters: Schema.String.annotate({
+      identifier: "patch",
+    }),
+    success: Schema.String,
+    dependencies: [CurrentDirectory],
+  }),
+  Tool.make("removeFile", {
+    description: "Remove a file.",
+    parameters: Schema.String.annotate({
+      identifier: "path",
+    }),
+    dependencies: [CurrentDirectory],
+  }),
+  Tool.make("renameFile", {
+    description:
+      "Rename or move a file, creating parent directories if needed.",
+    parameters: Schema.Struct({
+      from: Schema.String,
+      to: Schema.String,
+    }),
+    dependencies: [CurrentDirectory],
+  }),
+  Tool.make("mkdir", {
+    description: "Make a directory, creating parent directories if needed.",
+    parameters: Schema.String.annotate({
+      identifier: "path",
+    }),
+    dependencies: [CurrentDirectory],
+  }),
+  Tool.make("ls", {
+    description: "List the contents of a directory",
+    parameters: Schema.String.annotate({
+      identifier: "directory",
+    }),
+    success: Schema.Array(Schema.String),
+    dependencies: [CurrentDirectory],
+  }),
+  Tool.make("rg", {
+    description: "Search for a pattern in files using ripgrep.",
+    parameters: Schema.Struct({
+      pattern: Schema.String,
+      glob: Schema.optional(Schema.String).annotate({
+        documentation: "--glob",
+      }),
+      maxLines: Schema.optional(Schema.Finite).annotate({
+        documentation:
+          "The total maximum number of lines to return across all files (default: 500)",
+      }),
+    }),
+    success: Schema.String,
+    dependencies: [CurrentDirectory],
+  }),
+  Tool.make("glob", {
+    description: "Find files matching a glob pattern.",
+    parameters: Schema.String.annotate({
+      identifier: "pattern",
+    }),
+    success: Schema.Array(Schema.String),
+    dependencies: [CurrentDirectory],
+  }),
+  Tool.make("bash", {
+    description: "Run a bash command and return the output",
+    parameters: Schema.String.annotate({
+      identifier: "command",
+    }),
+    success: Schema.String,
+    dependencies: [CurrentDirectory],
+  }),
+  Tool.make("gh", {
+    description: "Use the GitHub CLI to run a command and return the output",
+    parameters: Schema.Array(Schema.String).annotate({
+      identifier: "args",
+    }),
+    success: Schema.String,
+    dependencies: [CurrentDirectory],
+  }),
+  Tool.make("subagent", {
+    description:
+      "Prompt another agent with the same tools to assist with a subtask. The subagent will return a markdown summary of the work it did.",
+    parameters: Schema.String.annotate({
+      identifier: "prompt",
+    }),
+    success: Schema.String,
+    dependencies: [SubagentContext],
+  }),
+  Tool.make("sleep", {
+    description: "Sleep for a specified number of milliseconds",
+    parameters: Schema.Finite.annotate({
+      identifier: "ms",
+    }),
+  }),
+  Tool.make("taskComplete", {
+    description:
+      "Only call this when you have fully completed the user's task. Provide a markdown summary of the work you have done.",
+    parameters: Schema.String.annotate({
+      identifier: "summary",
+    }),
+    dependencies: [TaskCompleteDeferred],
+  }),
+)
+
+/**
+ * @since 1.0.0
+ * @category Toolkit
+ */
+export const AgentToolHandlers = AgentTools.toLayer(
+  Effect.gen(function* () {
+    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+    const fs = yield* FileSystem.FileSystem
+    const pathService = yield* Path.Path
+
+    const execute = Effect.fn(function* (command: ChildProcess.Command) {
+      const handle = yield* spawner.spawn(command)
+      return yield* handle.all.pipe(
+        Stream.decodeText,
+        Stream.mkString,
+        Effect.flatMap(
+          Effect.fnUntraced(function* (output) {
+            const exitCode = yield* handle.exitCode
+            if (exitCode === 0) return output
+            return yield* Effect.die(
+              new Error(`Command failed with exit code ${exitCode}: ${output}`),
+            )
+          }),
+        ),
+      )
+    }, Effect.scoped)
+
+    return AgentTools.of({
+      readFile: Effect.fn("AgentTools.readFile")(function* (options) {
+        yield* Effect.logInfo(`Calling "readFile"`).pipe(
+          Effect.annotateLogs(options),
+        )
+        const cwd = yield* CurrentDirectory
+        let stream = pipe(
+          fs.stream(pathService.resolve(cwd, options.path)),
+          Stream.decodeText,
+          Stream.splitLines,
+        )
+        if (options.startLine) {
+          stream = Stream.drop(stream, options.startLine - 1)
+        }
+        if (options.endLine) {
+          stream = Stream.take(
+            stream,
+            options.endLine - (options.startLine ?? 1) + 1,
+          )
+        }
+        return yield* Stream.runCollect(stream).pipe(
+          Effect.map(Array.join("\n")),
+          Effect.catchReason("PlatformError", "NotFound", () =>
+            Effect.succeed(null),
+          ),
+          Effect.orDie,
+        )
+      }),
+      createFile: Effect.fn("AgentTools.createFile")(function* (options) {
+        yield* Effect.logInfo(`Calling "createFile"`).pipe(
+          Effect.annotateLogs({ path: options.path }),
+        )
+        const cwd = yield* CurrentDirectory
+        const path = pathService.resolve(cwd, options.path)
+        if (yield* fs.exists(path)) {
+          return yield* Effect.die("File already exists")
+        }
+        yield* fs.makeDirectory(pathService.dirname(path), {
+          recursive: true,
+        })
+        yield* fs.writeFileString(path, options.content)
+      }, Effect.orDie),
+      removeFile: Effect.fn("AgentTools.removeFile")(function* (path) {
+        yield* Effect.logInfo(`Calling "removeFile"`).pipe(
+          Effect.annotateLogs({ path }),
+        )
+        const cwd = yield* CurrentDirectory
+        return yield* fs.remove(pathService.resolve(cwd, path), { force: true })
+      }, Effect.orDie),
+      renameFile: Effect.fn("AgentTools.renameFile")(function* (options) {
+        yield* Effect.logInfo(`Calling "renameFile"`).pipe(
+          Effect.annotateLogs(options),
+        )
+        const cwd = yield* CurrentDirectory
+        const from = pathService.resolve(cwd, options.from)
+        const to = pathService.resolve(cwd, options.to)
+        yield* fs.makeDirectory(pathService.dirname(to), {
+          recursive: true,
+        })
+        return yield* fs.rename(from, to)
+      }, Effect.orDie),
+      mkdir: Effect.fn("AgentTools.mkdir")(function* (path) {
+        yield* Effect.logInfo(`Calling "mkdir"`).pipe(
+          Effect.annotateLogs({ path }),
+        )
+        const cwd = yield* CurrentDirectory
+        return yield* fs.makeDirectory(pathService.resolve(cwd, path), {
+          recursive: true,
+        })
+      }, Effect.orDie),
+      ls: Effect.fn("AgentTools.ls")(function* (path) {
+        yield* Effect.logInfo(`Calling "ls"`).pipe(
+          Effect.annotateLogs({ path }),
+        )
+        const cwd = yield* CurrentDirectory
+        return yield* fs
+          .readDirectory(pathService.resolve(cwd, path))
+          .pipe(Effect.orDie)
+      }),
+      rg: Effect.fn("AgentTools.rg")(function* (options) {
+        yield* Effect.logInfo(`Calling "rg"`).pipe(Effect.annotateLogs(options))
+        const cwd = yield* CurrentDirectory
+        const args = ["--max-filesize", "1M", "--line-number"]
+        if (options.glob) {
+          args.push("--glob", options.glob)
+        }
+        args.push(options.pattern)
+        let stream = pipe(
+          spawner.streamLines(
+            ChildProcess.make(Rg.rgPath, args, {
+              cwd,
+              stdin: "ignore",
+            }),
+          ),
+          Stream.map((line) => {
+            if (line.length <= 500) return line
+            return line.slice(0, 500) + "...[truncated]"
+          }),
+        )
+        stream = Stream.take(stream, options.maxLines ?? 500)
+        return yield* Stream.runCollect(stream).pipe(
+          Effect.map(Array.join("\n")),
+          Effect.orDie,
+        )
+      }),
+      glob: Effect.fn("AgentTools.glob")(function* (pattern) {
+        yield* Effect.logInfo(`Calling "glob"`).pipe(
+          Effect.annotateLogs({ pattern }),
+        )
+        const cwd = yield* CurrentDirectory
+        return yield* Effect.promise(() => Glob.glob(pattern, { cwd }))
+      }),
+      bash: Effect.fn("AgentTools.bash")(function* (command) {
+        yield* Effect.logInfo(`Calling "bash"`).pipe(
+          Effect.annotateLogs({ command }),
+        )
+        const cwd = yield* CurrentDirectory
+        const cmd = ChildProcess.make("bash", ["-c", command], {
+          cwd,
+          stdin: "ignore",
+        })
+        return yield* execute(cmd)
+      }, Effect.orDie),
+      gh: Effect.fn("AgentTools.gh")(function* (args) {
+        yield* Effect.logInfo(`Calling "gh"`).pipe(
+          Effect.annotateLogs({ args }),
+        )
+        const cwd = yield* CurrentDirectory
+        const cmd = ChildProcess.make("gh", args, {
+          cwd,
+          stdin: "ignore",
+        })
+        return yield* execute(cmd)
+      }, Effect.orDie),
+      sleep: Effect.fn("AgentTools.sleep")(function* (ms) {
+        yield* Effect.logInfo(`Calling "sleep" for ${ms}ms`)
+        return yield* Effect.sleep(ms)
+      }),
+      applyPatch: Effect.fn("AgentTools.applyPatch")(function* (patchText) {
+        yield* Effect.logInfo(`Calling "applyPatch"`)
+        const cwd = yield* CurrentDirectory
+        const fail = (path: string, reason: "delete" | "update") =>
+          Effect.fail(
+            new ApplyPatchError({
+              message: `verification failed: Failed to read file to ${reason}: ${path}`,
+            }),
+          )
+        const state = new Map<string, string | null>()
+        const steps = [] as Array<
+          | {
+              readonly type: "add" | "update"
+              readonly path: string
+              readonly next: string
+            }
+          | {
+              readonly type: "move"
+              readonly path: string
+              readonly movePath: string
+              readonly next: string
+            }
+          | {
+              readonly type: "delete"
+              readonly path: string
+            }
+        >
+        const out = [] as string[]
+        const rel = (path: string) =>
+          pathService.relative(cwd, path).replaceAll("\\", "/")
+        const load = Effect.fn("AgentTools.applyPatch.load")(function* (
+          path: string,
+          reason: "delete" | "update",
+        ) {
+          if (state.has(path)) {
+            const input = state.get(path)
+            if (input === null) {
+              return yield* fail(path, reason)
+            }
+            return input!
+          }
+
+          const input = yield* fs.readFileString(path)
+          state.set(path, input)
+          return input
+        })
+
+        for (const patch of parsePatch(patchText)) {
+          const path = pathService.resolve(cwd, patch.path)
+          switch (patch.type) {
+            case "add": {
+              const next =
+                patch.content.length === 0 || patch.content.endsWith("\n")
+                  ? patch.content
+                  : `${patch.content}\n`
+              state.set(path, next)
+              steps.push({
+                type: "add",
+                path,
+                next,
+              })
+              out.push(`A ${rel(path)}`)
+              break
+            }
+            case "delete": {
+              yield* load(path, "delete")
+              state.set(path, null)
+              steps.push({
+                type: "delete",
+                path,
+              })
+              out.push(`D ${rel(path)}`)
+              break
+            }
+            case "update": {
+              const input = yield* load(path, "update")
+              const next = patchChunks(path, input, patch.chunks)
+              const movePath =
+                patch.movePath === undefined
+                  ? undefined
+                  : pathService.resolve(cwd, patch.movePath)
+
+              if (movePath === undefined || movePath === path) {
+                state.set(path, next)
+                steps.push({
+                  type: "update",
+                  path,
+                  next,
+                })
+                out.push(`M ${rel(path)}`)
+                break
+              }
+
+              state.set(path, null)
+              state.set(movePath, next)
+              steps.push({
+                type: "move",
+                path,
+                movePath,
+                next,
+              })
+              out.push(`M ${rel(movePath)}`)
+              break
+            }
+          }
+        }
+
+        for (const step of steps) {
+          switch (step.type) {
+            case "add":
+            case "update": {
+              yield* fs.makeDirectory(pathService.dirname(step.path), {
+                recursive: true,
+              })
+              yield* fs.writeFileString(step.path, step.next)
+              break
+            }
+            case "move": {
+              yield* fs.makeDirectory(pathService.dirname(step.movePath), {
+                recursive: true,
+              })
+              yield* fs.writeFileString(step.movePath, step.next)
+              yield* fs.remove(step.path)
+              break
+            }
+            case "delete": {
+              yield* fs.remove(step.path)
+              break
+            }
+          }
+        }
+
+        return `Success. Updated the following files:\n${out.join("\n")}`
+      }, Effect.orDie),
+      subagent: Effect.fn("AgentTools.subagent")(function* (prompt) {
+        yield* Effect.logInfo(`Calling "subagent"`).pipe(
+          Effect.annotateLogs({ prompt }),
+        )
+        const context = yield* SubagentContext
+        return yield* context.spawn({ prompt })
+      }, Effect.orDie),
+      taskComplete: Effect.fn("AgentTools.taskComplete")(function* (message) {
+        const deferred = yield* TaskCompleteDeferred
+        yield* Deferred.succeed(deferred, message)
+      }),
+    })
+  }),
+)
+
+class ApplyPatchError extends Data.TaggedClass("ApplyPatchError")<{
+  readonly message: string
+}> {}

package/src/ApplyPatch.test.ts

@@ -0,0 +1,154 @@
+import { describe, expect, it } from "vitest"
+import { parsePatch, patchContent } from "./ApplyPatch.ts"
+
+describe("patchContent", () => {
+  it("applies raw hunks", () => {
+    expect(
+      patchContent("sample.txt", "line1\nline2\n", "@@\n-line2\n+changed"),
+    ).toBe("line1\nchanged\n")
+  })
+
+  it("does not treat raw marker text as a wrapped patch", () => {
+    expect(
+      patchContent(
+        "sample.txt",
+        "*** Begin Patch\nfinish\n",
+        "@@\n-*** Begin Patch\n+*** End Patch",
+      ),
+    ).toBe("*** End Patch\nfinish\n")
+  })
+
+  it("parses wrapped single-file patches", () => {
+    expect(
+      patchContent(
+        "sample.txt",
+        "alpha\nomega\n",
+        "*** Begin Patch\n*** Update File: ignored.txt\n@@\n alpha\n+beta\n omega\n*** End Patch",
+      ),
+    ).toBe("alpha\nbeta\nomega\n")
+  })
+
+  it("parses multi-file wrapped patches", () => {
+    expect(
+      parsePatch(
+        [
+          "*** Begin Patch",
+          "*** Add File: hello.txt",
+          "+Hello world",
+          "*** Update File: src/app.ts",
+          "*** Move to: src/main.ts",
+          "@@ keep",
+          " keep",
+          "-old",
+          "+new",
+          "*** Delete File: obsolete.txt",
+          "*** End Patch",
+        ].join("\n"),
+      ),
+    ).toEqual([
+      {
+        type: "add",
+        path: "hello.txt",
+        content: "Hello world",
+      },
+      {
+        type: "update",
+        path: "src/app.ts",
+        movePath: "src/main.ts",
+        chunks: [
+          {
+            ctx: "keep",
+            old: ["keep", "old"],
+            next: ["keep", "new"],
+          },
+        ],
+      },
+      {
+        type: "delete",
+        path: "obsolete.txt",
+      },
+    ])
+  })
+
+  it("parses wrapped patches when hunks contain marker text", () => {
+    expect(
+      parsePatch(
+        [
+          "*** Begin Patch",
+          "*** Update File: src/app.ts",
+          "@@",
+          " *** End Patch",
+          "-old",
+          "+new",
+          "*** Delete File: obsolete.txt",
+          "*** End Patch",
+        ].join("\n"),
+      ),
+    ).toEqual([
+      {
+        type: "update",
+        path: "src/app.ts",
+        chunks: [
+          {
+            old: ["*** End Patch", "old"],
+            next: ["*** End Patch", "new"],
+          },
+        ],
+      },
+      {
+        type: "delete",
+        path: "obsolete.txt",
+      },
+    ])
+  })
+
+  it("parses heredoc-wrapped hunks", () => {
+    expect(
+      patchContent("sample.txt", "old\n", "<<'EOF'\n@@\n-old\n+new\nEOF"),
+    ).toBe("new\n")
+  })
+
+  it("matches lines after trimming trailing whitespace", () => {
+    expect(patchContent("sample.txt", "old  \n", "@@\n-old\n+new")).toBe(
+      "new\n",
+    )
+  })
+
+  it("matches lines after trimming surrounding whitespace", () => {
+    expect(patchContent("sample.txt", "  old\n", "@@\n-old\n+new")).toBe(
+      "new\n",
+    )
+  })
+
+  it("matches lines after normalizing Unicode punctuation", () => {
+    expect(
+      patchContent("sample.txt", "Don’t wait…\n", "@@\n-Don't wait...\n+Done"),
+    ).toBe("Done\n")
+  })
+
+  it("matches EOF hunks from the end of the file", () => {
+    expect(
+      patchContent(
+        "tail.txt",
+        "start\nmarker\nend\nmiddle\nmarker\nend\n",
+        "@@\n-marker\n-end\n+marker-changed\n+end\n*** End of File",
+      ),
+    ).toBe("start\nmarker\nend\nmiddle\nmarker-changed\nend\n")
+  })
+
+  it("preserves CRLF files", () => {
+    expect(patchContent("crlf.txt", "old\r\n", "@@\n-old\n+new")).toBe(
+      "new\r\n",
+    )
+  })
+
+  it("rejects multi-file wrapped patches", () => {
+    expect(() =>
+      patchContent(
+        "sample.txt",
+        "line1\nline2\n",
+        "*** Begin Patch\n*** Update File: a.txt\n@@\n-line2\n+changed\n*** Update File: b.txt\n@@\n-old\n+new\n*** End Patch",
+      ),
+    ).toThrow("only one update file section is supported")
+  })
+})