clanka 0.0.28 → 0.1.0

package/src/Agent.test.ts

@@ -1,159 +0,0 @@
-import { NodeServices } from "@effect/platform-node"
-import { Effect, Layer, Stream } from "effect"
-import { describe, it } from "@effect/vitest"
-import { expect } from "vitest"
-import { AgentModelConfig, make } from "./Agent.ts"
-import { pretty } from "./OutputFormatter.ts"
-import { LanguageModel, Prompt } from "effect/unstable/ai"
-import * as Model from "effect/unstable/ai/Model"
-import { Executor } from "./Executor.ts"
-import { ToolkitRenderer } from "./ToolkitRenderer.ts"
-import { AgentToolHandlersTest } from "./AgentTools.ts"
-
-const usage = {
-  inputTokens: {
-    uncached: undefined,
-    total: undefined,
-    cacheRead: undefined,
-    cacheWrite: undefined,
-  },
-  outputTokens: {
-    total: undefined,
-    text: undefined,
-    reasoning: undefined,
-  },
-}
-
-const promptText = (prompt: Prompt.Prompt) =>
-  prompt.content
-    .flatMap((message) => {
-      if (typeof message.content === "string") {
-        return [message.content]
-      }
-      return message.content.flatMap((part) => {
-        switch (part.type) {
-          case "text":
-          case "reasoning":
-            return [part.text]
-
-          default:
-            return []
-        }
-      })
-    })
-    .join("\n")
-
-const scriptResponse = (script: string) =>
-  Stream.fromIterable([
-    { type: "text-start", id: "script" } as const,
-    { type: "text-delta", id: "script", delta: script } as const,
-    { type: "text-end", id: "script" } as const,
-    {
-      type: "finish",
-      reason: "stop",
-      usage,
-      response: undefined,
-    } as const,
-  ])
-
-const TestModel = Model.make(
-  "test-provider",
-  "test-model",
-  Layer.effect(
-    LanguageModel.LanguageModel,
-    LanguageModel.make({
-      generateText: () => Effect.succeed([]),
-      streamText: ({ prompt }) => {
-        const text = promptText(prompt)
-
-        if (text.includes("grandchild task")) {
-          return scriptResponse(
-            [
-              'console.log("grandchild output")',
-              'await taskComplete("grandchild summary")',
-            ].join("\n"),
-          )
-        }
-
-        if (text.includes("child task")) {
-          return scriptResponse(
-            [
-              'const result = await delegate("grandchild task")',
-              "await taskComplete(`child summary: ${result}`)",
-            ].join("\n"),
-          )
-        }
-
-        return scriptResponse(
-          [
-            'const result = await delegate("child task")',
-            "await taskComplete(`root summary: ${result}`)",
-          ].join("\n"),
-        )
-      },
-    }),
-  ),
-)
-
-describe("Agent", () => {
-  it.effect("forwards nested subagent output", () =>
-    Effect.gen(function* () {
-      const seen = [] as Array<string>
-      const agent = yield* make({
-        directory: process.cwd(),
-        prompt: "root task",
-      })
-
-      const output = yield* agent.output.pipe(
-        Stream.tap((part) =>
-          Effect.sync(() => {
-            switch (part._tag) {
-              case "SubagentStart":
-              case "SubagentComplete":
-                seen.push(`${part._tag}:${part.id}`)
-                break
-
-              case "SubagentPart":
-                seen.push(`${part._tag}:${part.id}:${part.part._tag}`)
-                break
-
-              default:
-                seen.push(part._tag)
-                break
-            }
-          }),
-        ),
-        pretty,
-        Stream.mkString,
-      )
-
-      expect(seen).toContain("SubagentStart:1")
-      expect(seen).toContain("SubagentStart:2")
-      expect(seen).toContain("SubagentPart:2:ScriptStart")
-      expect(seen).toContain("SubagentPart:2:ScriptOutput")
-      expect(seen).toContain("SubagentComplete:2")
-      expect(seen).toContain("SubagentComplete:1")
-
-      expect(output).toContain("Subagent #1 starting")
-      expect(output).toContain("Subagent #2 starting")
-      expect(output).toContain("grandchild output")
-      expect(output).toContain("Subagent #2 complete")
-      expect(output).toContain("Task complete:")
-      expect(output).toContain(
-        "root summary: child summary: grandchild summary",
-      )
-    }).pipe(
-      Effect.provide(
-        Layer.mergeAll(
-          AgentToolHandlersTest,
-          TestModel,
-          AgentModelConfig.layer({
-            supportsNoTools: true,
-          }),
-          Executor.layer,
-          ToolkitRenderer.layer,
-        ).pipe(Layer.provideMerge(NodeServices.layer)),
-      ),
-    ),
-  )
-})

package/src/Executor.ts

@@ -1,151 +0,0 @@
-/**
- * @since 1.0.0
- */
-import {
-  Cause,
-  Console,
-  Effect,
-  Exit,
-  Fiber,
-  Layer,
-  Queue,
-  Scope,
-  ServiceMap,
-  Stream,
-} from "effect"
-import { Tool, Toolkit } from "effect/unstable/ai"
-import * as NodeConsole from "node:console"
-import * as NodeVm from "node:vm"
-import { Writable } from "node:stream"
-
-/**
- * @since 1.0.0
- * @category Services
- */
-export class Executor extends ServiceMap.Service<
-  Executor,
-  {
-    execute<Tools extends Record<string, Tool.Any>>(options: {
-      readonly tools: Toolkit.WithHandler<Tools>
-      readonly script: string
-    }): Stream.Stream<string, never, Tool.HandlerServices<Tools[keyof Tools]>>
-  }
->()("clanka/Executor") {
-  static readonly layer = Layer.effect(
-    Executor,
-    // oxlint-disable-next-line require-yield
-    Effect.gen(function* () {
-      const execute = Effect.fnUntraced(function* <
-        Tools extends Record<string, Tool.Any>,
-      >(options: {
-        readonly tools: Toolkit.WithHandler<Tools>
-        readonly script: string
-      }) {
-        const output = yield* Queue.unbounded<string, Cause.Done>()
-        const console = yield* makeConsole(output)
-        const handlerScope = Scope.makeUnsafe("parallel")
-        const trackFiber = Fiber.runIn(handlerScope)
-
-        yield* Effect.gen(function* () {
-          const console = yield* Console.Console
-          const services = yield* Effect.services()
-          let running = 0
-
-          const script = new NodeVm.Script(`async function main() {
-${options.script}
-}`)
-          const sandbox: ScriptSandbox = {
-            main: defaultMain,
-            console,
-            fetch,
-            process: undefined,
-          }
-
-          for (const [name, tool] of Object.entries(options.tools.tools)) {
-            const handler = services.mapUnsafe.get(
-              tool.id,
-            ) as Tool.Handler<string>
-
-            const handlerServices = ServiceMap.merge(services, handler.services)
-            const runFork = Effect.runForkWith(handlerServices)
-
-            // oxlint-disable-next-line typescript/no-explicit-any
-            sandbox[name] = function (params: any) {
-              running++
-              const fiber = trackFiber(runFork(handler.handler(params, {})))
-              return new Promise((resolve, reject) => {
-                fiber.addObserver((exit) => {
-                  running--
-                  if (exit._tag === "Success") {
-                    resolve(exit.value)
-                  } else {
-                    if (Cause.hasInterruptsOnly(exit.cause)) return
-                    reject(Cause.squash(exit.cause))
-                  }
-                })
-              })
-            }
-          }
-
-          script.runInNewContext(sandbox, {
-            timeout: 1000,
-          })
-          yield* Effect.promise(sandbox.main)
-          while (true) {
-            yield* Effect.yieldNow
-            if (running === 0) break
-          }
-        }).pipe(
-          Effect.ensuring(Scope.close(handlerScope, Exit.void)),
-          Effect.catchCause(Effect.logFatal),
-          Effect.provideService(Console.Console, console),
-          Effect.ensuring(Queue.end(output)),
-          Effect.forkScoped,
-        )
-
-        return Stream.fromQueue(output)
-      }, Stream.unwrap)
-
-      return Executor.of({
-        execute,
-      })
-    }),
-  )
-}
-
-interface ScriptSandbox {
-  main: () => Promise<void>
-  console: Console.Console
-  [toolName: string]: unknown
-}
-
-const defaultMain = () => Promise.resolve()
-
-const makeConsole = Effect.fn(function* (
-  queue: Queue.Queue<string, Cause.Done>,
-) {
-  const writable = new QueueWriteStream(queue)
-  const newConsole = new NodeConsole.Console(writable)
-  yield* Effect.addFinalizer(() => {
-    writable.end()
-    return Effect.void
-  })
-  return newConsole
-})
-
-class QueueWriteStream extends Writable {
-  readonly queue: Queue.Enqueue<string, Cause.Done>
-  constructor(queue: Queue.Enqueue<string, Cause.Done>) {
-    super()
-    this.queue = queue
-  }
-  _write(
-    // oxlint-disable-next-line typescript/no-explicit-any
-    chunk: any,
-    _encoding: BufferEncoding,
-    callback: (error?: Error | null) => void,
-  ): void {
-    Queue.offerUnsafe(this.queue, chunk.toString())
-    callback()
-  }
-}