clanka 0.2.72 → 0.3.0

package/src/cli.ts

@@ -7,6 +7,8 @@ import * as Flag from "effect/unstable/cli/Flag"
 import * as NodeServices from "@effect/platform-node/NodeServices"
 import * as NodeRuntime from "@effect/platform-node/NodeRuntime"
 import * as NodeSocket from "@effect/platform-node/NodeSocket"
+import * as Acp from "./Acp.ts"
+import * as AgentExecutor from "./AgentExecutor.ts"
 import * as Codex from "./Codex.ts"
 import * as Copilot from "./Copilot.ts"
 import * as Agent from "./Agent.ts"
@@ -15,14 +17,62 @@ import * as OutputFormatter from "./OutputFormatter.ts"
 import * as Stdio from "effect/Stdio"
 import { pipe } from "effect/Function"
 import * as Layer from "effect/Layer"
+import * as Logger from "effect/Logger"
 import * as Path from "effect/Path"
+import * as Schema from "effect/Schema"
+import type * as LanguageModel from "effect/unstable/ai/LanguageModel"
+import type * as Model from "effect/unstable/ai/Model"
 import * as Config from "effect/Config"
 import * as KeyValueStore from "effect/unstable/persistence/KeyValueStore"
 import * as Option from "effect/Option"
 import { OpenAiClient, OpenAiEmbeddingModel } from "@effect/ai-openai"
 import { DeviceCodeHandler } from "./index.ts"
 
-const provider = Flag.Literals("provider", ["openai", "copilot"]).pipe(
+const version = "0.0.1"
+
+type Provider = "openai" | "copilot"
+
+const providers: ReadonlyArray<Provider> = ["openai", "copilot"]
+
+const withSubagentModel = <E, R>(
+  model: Layer.Layer<
+    LanguageModel.LanguageModel | Model.ProviderName | Model.ModelName,
+    E,
+    R
+  >,
+) => Layer.merge(model, Agent.layerSubagentModel(model))
+
+const modelLayer = (provider: Provider, model: string, effort: string) =>
+  provider === "openai"
+    ? withSubagentModel(
+        Codex.modelWebSocket(model, { reasoning: { effort: effort as any } }),
+      ).pipe(Layer.provide(Codex.layerClient))
+    : withSubagentModel(Copilot.model(model, { reasoning: { effort } })).pipe(
+        Layer.provide(Copilot.layerClient),
+      )
+
+const parseModelId = (modelId: string) => {
+  const [provider, model, effort, ...rest] = modelId.split("/")
+  return provider !== undefined &&
+    providers.includes(provider as Provider) &&
+    model !== undefined &&
+    effort !== undefined &&
+    rest.length === 0
+    ? Option.some({ provider: provider as Provider, model, effort })
+    : Option.none()
+}
+
+const ModelId = Schema.String.pipe(
+  Schema.check(
+    Schema.makeFilter(
+      (modelId: string) =>
+        Option.isSome(parseModelId(modelId)) ||
+        `Invalid model "${modelId}", expected <provider>/<model>/<effort>`,
+    ),
+  ),
+)
+
+const provider = Flag.Literals("provider", providers).pipe(
   Flag.withAlias("p"),
   Flag.withFallbackPrompt(
     Prompt.Select({
@@ -123,6 +173,42 @@ const Search = (directory: string) =>
     }),
   ).pipe(Layer.provide([NodeServices.layer, NodeHttpClient.layerUndici]))
 
+const acpModel = Flag.String("model").pipe(
+  Flag.withAlias("m"),
+  Flag.withDescription(
+    "Default model as <provider>/<model>/<effort>, e.g. openai/gpt-6-astra/medium",
+  ),
+  Flag.withSchema(ModelId),
+  Flag.withDefault("openai/gpt-6-astra/medium"),
+)
+
+const acp = Command.make("acp", { model: acpModel }).pipe(
+  Command.withDescription(
+    "Run as an Agent Client Protocol (ACP) server over stdio",
+  ),
+  Command.withHandler(({ model }) =>
+    Acp.runStdio({
+      version,
+      defaultModel: model,
+      makeAgent: (cwd) =>
+        Agent.make.pipe(
+          Effect.provide(AgentExecutor.layerLocal({ directory: cwd })),
+        ),
+      makeModel: (modelId) =>
+        Option.map(parseModelId(modelId), ({ provider, model, effort }) =>
+          modelLayer(provider, model, effort),
+        ),
+    }),
+  ),
+  Command.provide(
+    Layer.mergeAll(
+      Agent.ConversationMode.layer(true),
+      Layer.succeed(Logger.LogToStderr, true),
+      DeviceCodeHandler.layerLog,
+    ),
+  ),
+)
+
 Command.make("clanka", { provider, model, semantic, prompt }).pipe(
   Command.withHandler(
     Effect.fnUntraced(function* ({
@@ -133,40 +219,7 @@ Command.make("clanka", { provider, model, semantic, prompt }).pipe(
     }) {
       const stdio = yield* Stdio.Stdio
       const [model, reasoning] = modelRaw.split("/") as [string, string]
-      const Model =
-        provider === "openai"
-          ? Codex.modelWebSocket(model, {
-              reasoning: {
-                effort: reasoning as any,
-              },
-            }).pipe(
-              Layer.merge(
-                Agent.layerSubagentModel(
-                  Codex.modelWebSocket(model, {
-                    reasoning: {
-                      effort: reasoning as any,
-                    },
-                  }),
-                ),
-              ),
-              Layer.provide(Codex.layerClient),
-            )
-          : Copilot.model(model, {
-              reasoning: {
-                effort: reasoning,
-              },
-            }).pipe(
-              Layer.merge(
-                Agent.layerSubagentModel(
-                  Copilot.model(model, {
-                    reasoning: {
-                      effort: reasoning,
-                    },
-                  }),
-                ),
-              ),
-              Layer.provide(Copilot.layerClient),
-            )
+      const Model = modelLayer(provider, model, reasoning)
 
       return yield* Effect.gen(function* () {
         const agent = yield* Agent.Agent
@@ -214,8 +267,9 @@ Command.make("clanka", { provider, model, semantic, prompt }).pipe(
   Command.provide(({ prompt }) =>
     Agent.ConversationMode.layer(Option.isNone(prompt)),
   ),
+  Command.withSubcommands([acp]),
   Command.run({
-    version: "0.0.1",
+    version,
   }),
   Effect.provide([
     NodeServices.layer,

package/src/index.ts

@@ -1,3 +1,8 @@
+/**
+ * @since 1.0.0
+ */
+export * as Acp from "./Acp.ts"
+
 /**
  * @since 1.0.0
  */