clanka 0.7.6 → 0.8.0

package/src/Agent.test.ts

@@ -18,7 +18,7 @@ import type * as Response from "effect/unstable/ai/Response"
 import * as ResponseIdTracker from "effect/unstable/ai/ResponseIdTracker"
 import * as Agent from "./Agent.ts"
 import * as AgentExecutor from "./AgentExecutor.ts"
-import type * as AgentOutput from "./AgentOutput.ts"
+import * as AgentOutput from "./AgentOutput.ts"
 import * as Compaction from "./Compaction.ts"
 
 const capabilities = new AgentExecutor.Capabilities({
@@ -310,11 +310,19 @@ const toolCall = (id: string, script: string): Response.StreamPartEncoded => ({
 const finish = (
   contextTokens: number,
   reason: "stop" | "tool-calls" = "tool-calls",
+  cache: {
+    readonly read?: number | undefined
+    readonly write?: number | undefined
+  } = {},
 ): Response.StreamPartEncoded => ({
   type: "finish",
   reason,
   usage: {
-    inputTokens: { total: contextTokens },
+    inputTokens: {
+      total: contextTokens,
+      cacheRead: cache.read,
+      cacheWrite: cache.write,
+    },
     outputTokens: { total: 10 },
   },
 })
@@ -524,6 +532,50 @@ it.layer(localExecutorLayer, { excludeTestServices: true })(
 
 // --- tests -------------------------------------------------------------------
 
+describe("Agent usage", () => {
+  it.effect("accumulates provider cache reads and writes", () =>
+    Effect.gen(function* () {
+      const { exit, outputs } = yield* runAgentCollect({
+        executor: makeExecutor(() => Stream.succeed("done")),
+        respond: (_call, index) => {
+          switch (index) {
+            case 0:
+              return Stream.fromIterable([
+                toolCall("call-1", "console.log('done')"),
+                finish(100, "tool-calls", { read: 25, write: 5 }),
+              ])
+            case 1:
+              return Stream.fromIterable([
+                ...text("complete"),
+                finish(60, "stop", { read: 15, write: 3 }),
+              ])
+            default:
+              return Stream.die(`unexpected model call #${index}`)
+          }
+        },
+      })
+
+      assert.deepStrictEqual(exit, Exit.succeed("complete"))
+      assert.deepStrictEqual(outputsOfTag(outputs, "Usage"), [
+        new AgentOutput.Usage({
+          contextTokens: 100,
+          inputTokens: 100,
+          outputTokens: 10,
+          cacheRead: 25,
+          cacheWrite: 5,
+        }),
+        new AgentOutput.Usage({
+          contextTokens: 60,
+          inputTokens: 160,
+          outputTokens: 20,
+          cacheRead: 40,
+          cacheWrite: 8,
+        }),
+      ])
+    }),
+  )
+})
+
 describe("Agent execute output cap", () => {
   const dump = "DUMP-HEAD " + filler("log", 40_000) + " DUMP-TAIL"
 

package/src/Agent.ts

@@ -211,6 +211,8 @@ ${content}
     const output = yield* Queue.make<Output, AgentFinished | AiError.AiError>()
     let inputTokens = 0
     let outputTokens = 0
+    let cacheRead = 0
+    let cacheWrite = 0
     const prompt = opts.disableHistory ? MutableRef.make(Prompt.empty) : history
 
     MutableRef.update(prompt, Prompt.concat(opts.prompt))
@@ -536,6 +538,12 @@ ${content}
                   if (usage.outputTokens.total !== undefined) {
                     outputTokens += usage.outputTokens.total
                   }
+                  if (usage.inputTokens.cacheRead !== undefined) {
+                    cacheRead += usage.inputTokens.cacheRead
+                  }
+                  if (usage.inputTokens.cacheWrite !== undefined) {
+                    cacheWrite += usage.inputTokens.cacheWrite
+                  }
                   if (usage.inputTokens.total !== undefined) {
                     lastContextTokens = usage.inputTokens.total
                     inputTokens += usage.inputTokens.total
@@ -545,6 +553,8 @@ ${content}
                         contextTokens: usage.inputTokens.total,
                         inputTokens,
                         outputTokens,
+                        cacheRead,
+                        cacheWrite,
                       }),
                     })
                   }

package/src/AgentOutput.ts

@@ -87,6 +87,14 @@ export class Usage extends Schema.TaggedClass<Usage>()("Usage", {
   contextTokens: Schema.Number,
   inputTokens: Schema.Number,
   outputTokens: Schema.Number,
+  /**
+   * Cumulative cache reads included in `inputTokens`. Zero is not proof of no cache activity.
+   */
+  cacheRead: Schema.Number,
+  /**
+   * Cumulative cache writes included in `inputTokens`. Zero is not proof of no cache activity.
+   */
+  cacheWrite: Schema.Number,
 }) {}
 
 /**

package/src/AgentTools.test.ts

@@ -0,0 +1,116 @@
+import { assert, describe, it } from "@effect/vitest"
+import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient"
+import * as NodeServices from "@effect/platform-node/NodeServices"
+import * as Effect from "effect/Effect"
+import * as FileSystem from "effect/FileSystem"
+import * as Layer from "effect/Layer"
+import * as Path from "effect/Path"
+import * as AgentExecutor from "./AgentExecutor.ts"
+
+const match = "ignored-directory-regression-match"
+
+const withProject = <A, E, R>(f: Effect.Effect<A, E, R>) =>
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    const path = yield* Path.Path
+    const project = yield* fs.makeTempDirectoryScoped()
+    yield* fs.makeDirectory(path.join(project, ".git"))
+    yield* fs.writeFileString(
+      path.join(project, ".gitignore"),
+      "node_modules/\n",
+    )
+    yield* fs.makeDirectory(path.join(project, "src"))
+    yield* fs.makeDirectory(path.join(project, ".git", "src"))
+    yield* fs.makeDirectory(path.join(project, "node_modules", "dependency"), {
+      recursive: true,
+    })
+    yield* fs.makeDirectory(
+      path.join(project, "node_modules", "dependency", "src"),
+    )
+    yield* fs.writeFileString(
+      path.join(project, "src", "visible.ts"),
+      `${match} visible`,
+    )
+    yield* fs.writeFileString(
+      path.join(project, "node_modules", "dependency", "ignored.ts"),
+      `${match} ignored`,
+    )
+    yield* fs.writeFileString(
+      path.join(project, "node_modules", "dependency", "src", "inner.ts"),
+      `${match} ignored dependency source`,
+    )
+    yield* fs.writeFileString(
+      path.join(project, ".git", "src", "hidden.ts"),
+      `${match} hidden git source`,
+    )
+
+    return yield* f.pipe(
+      Effect.provide(
+        AgentExecutor.layerLocal({ directory: project }).pipe(
+          Layer.provide(NodeHttpClient.layerUndici),
+        ),
+      ),
+    )
+  }).pipe(Effect.provide(NodeServices.layer), Effect.scoped)
+
+const rg = (glob?: string) =>
+  Effect.gen(function* () {
+    const executor = yield* AgentExecutor.AgentExecutor
+    const output = yield* executor.executeUnsafe({
+      tool: "rg",
+      params: { pattern: match, glob },
+    })
+    assert.isString(output)
+    return output
+  })
+
+describe("rg", () => {
+  it.effect("does not search ignored directories by default", () =>
+    withProject(
+      Effect.gen(function* () {
+        const output = yield* rg()
+        assert.include(output, "src/visible.ts")
+        assert.notInclude(output, "node_modules/dependency/ignored.ts")
+      }),
+    ),
+  )
+
+  it.effect("does not search ignored directories for an ordinary glob", () =>
+    withProject(
+      Effect.gen(function* () {
+        const output = yield* rg("**/*.ts")
+        assert.include(output, "src/visible.ts")
+        assert.notInclude(output, "node_modules/dependency/ignored.ts")
+      }),
+    ),
+  )
+
+  it.effect("does not search ignored paths for an ordinary scoped glob", () =>
+    withProject(
+      Effect.gen(function* () {
+        const output = yield* rg("**/src/*.ts")
+        assert.include(output, "src/visible.ts")
+        assert.notInclude(output, "node_modules/dependency/src/inner.ts")
+        assert.notInclude(output, ".git/src/hidden.ts")
+      }),
+    ),
+  )
+
+  it.effect("searches an ignored directory explicitly named in the glob", () =>
+    withProject(
+      Effect.gen(function* () {
+        const output = yield* rg("**/node_modules/**")
+        assert.include(output, "node_modules/dependency/ignored.ts")
+      }),
+    ),
+  )
+
+  it.effect("searches a root-relative ignored directory glob", () =>
+    withProject(
+      Effect.gen(function* () {
+        const output = yield* rg("node_modules/**")
+        assert.include(output, "node_modules/dependency/ignored.ts")
+      }),
+    ),
+  )
+})

package/src/AgentTools.ts

@@ -82,6 +82,12 @@ export class ImageAttacher extends Context.Service<
   (image: ImageAttachment) => Effect.Effect<void>
 >()("clanka/AgentTools/ImageAttacher") {}
 
+const globNamesDirectory = (glob: string) =>
+  glob
+    .split("/")
+    .slice(0, -1)
+    .some((segment) => segment.length > 0 && !/[*?[\]{}]/.test(segment))
+
 /**
  * @since 1.0.0
  * @category Context
@@ -440,24 +446,38 @@ export const AgentToolHandlersNoDeps = AgentToolsWithSearch.toLayer(
         if (options.filesOnly) {
           args.push("--files-with-matches")
         }
+        const searchesIgnoredFiles =
+          options.glob !== undefined && !options.glob.startsWith("*")
         if (options.glob) {
           args.push("--glob", options.glob)
-          if (!options.glob.startsWith("*")) {
+          if (searchesIgnoredFiles) {
             args.push("-uu")
           }
         }
         args.push(options.pattern)
-        let stream = spawner.streamLines(
-          ChildProcess.make("rg", args, {
-            cwd,
-            stdin: "ignore",
-          }),
-        )
-        stream = Stream.take(stream, options.maxLines ?? 500)
-        return yield* Stream.runCollect(stream).pipe(
-          Effect.map(Array.join("\n")),
-          Effect.orDie,
-        )
+        const run = Effect.fnUntraced(function* (args: Array<string>) {
+          let stream = spawner.streamLines(
+            ChildProcess.make("rg", args, {
+              cwd,
+              stdin: "ignore",
+            }),
+          )
+          stream = Stream.take(stream, options.maxLines ?? 500)
+          return yield* Stream.runCollect(stream).pipe(
+            Effect.map(Array.join("\n")),
+            Effect.orDie,
+          )
+        })
+        const output = yield* run(args)
+        if (
+          output.length > 0 ||
+          searchesIgnoredFiles ||
+          options.glob === undefined ||
+          !globNamesDirectory(options.glob)
+        ) {
+          return output
+        }
+        return yield* run(args.slice(0, -1).concat("-uu", options.pattern))
       }),
       glob: Effect.fn("AgentTools.glob")(function* (pattern) {
         yield* Effect.logInfo(`Calling "glob"`).pipe(

package/src/cli.ts

@@ -64,14 +64,25 @@ const modelLayer = (provider: Provider, model: string, effort: string) =>
           Layer.provide(Copilot.layerClient),
         )
 
+const isProvider = (provider: string | undefined): provider is Provider =>
+  providers.includes(provider as Provider)
+
+// `<provider>/<model>/<effort>` as accepted by the `acp` --model flag.
 const parseModelId = (modelId: string) => {
   const [provider, model, effort, ...rest] = modelId.split("/")
-  return provider !== undefined &&
-    providers.includes(provider as Provider) &&
+  return isProvider(provider) &&
     model !== undefined &&
-    effort !== undefined &&
+    Schema.is(Acp.ThoughtLevel)(effort) &&
     rest.length === 0
-    ? Option.some({ provider: provider as Provider, model, effort })
+    ? Option.some({ model: `${provider}:${model}`, thoughtLevel: effort })
+    : Option.none()
+}
+
+// `<provider>:<model>` as advertised over ACP.
+const parseAcpModelId = (modelId: string) => {
+  const [provider, model, ...rest] = modelId.split(":")
+  return isProvider(provider) && model !== undefined && rest.length === 0
+    ? Option.some({ provider, model })
     : Option.none()
 }
 
@@ -80,7 +91,7 @@ const ModelId = Schema.String.pipe(
     Schema.makeFilter(
       (modelId: string) =>
         Option.isSome(parseModelId(modelId)) ||
-        `Invalid model "${modelId}", expected <provider>/<model>/<effort>`,
+        `Invalid model "${modelId}", expected <provider>/<model>/<effort> with effort one of ${Acp.ThoughtLevel.literals.join(", ")}`,
     ),
   ),
 )
@@ -192,6 +203,7 @@ const acpModel = Flag.String("model").pipe(
   ),
   Flag.withSchema(ModelId),
   Flag.withDefault("openai/gpt-6-astra/medium"),
+  Flag.map((modelId) => Option.getOrThrow(parseModelId(modelId))),
 )
 
 const acp = Command.make("acp", { model: acpModel, compaction }).pipe(
@@ -201,14 +213,15 @@ const acp = Command.make("acp", { model: acpModel, compaction }).pipe(
   Command.withHandler(({ model }) =>
     Acp.runStdio({
       version,
-      defaultModel: model,
+      defaultModel: model.model,
+      defaultThoughtLevel: model.thoughtLevel,
       makeAgent: (cwd) =>
         Agent.make.pipe(
           Effect.provide(AgentExecutor.layerLocal({ directory: cwd })),
         ),
-      makeModel: (modelId) =>
-        Option.map(parseModelId(modelId), ({ provider, model, effort }) =>
-          modelLayer(provider, model, effort),
+      makeModel: (modelId, thoughtLevel) =>
+        Option.map(parseAcpModelId(modelId), ({ provider, model }) =>
+          modelLayer(provider, model, thoughtLevel),
         ),
     }),
   ),