@akanjs/cli 3.0.0-beta.9 → 3.0.0

package/index-c6eggbee.js

@@ -0,0 +1,123 @@
+// @bun
+// pkgs/@akanjs/devkit/codeAgent/agent/akanCodeModel.ts
+var akanCodeDefaultModel2 = { provider: "deepseek", id: "deepseek-flash" };
+var catalogueMissesImages = new Set(["deepseek/deepseek-v4-flash"]);
+var correctInputs = (model) => {
+  if (!model || model.input.includes("image"))
+    return model;
+  if (!catalogueMissesImages.has(`${model.provider}/${model.id}`))
+    return model;
+  return { ...model, input: [...model.input, "image"] };
+};
+var akanCodeModel2 = async (runtime, ref) => {
+  if (ref) {
+    const requested = runtime.getModel(ref.provider, ref.id);
+    if (!requested)
+      throw new Error(`Unknown model: ${ref.provider}/${ref.id}`);
+    if (!runtime.hasConfiguredAuth(ref.provider))
+      throw new Error(`No API key configured for ${ref.provider}. Set ${ref.provider.toUpperCase()}_API_KEY.`);
+    return correctInputs(requested);
+  }
+  const fallback = runtime.getModel(akanCodeDefaultModel2.provider, akanCodeDefaultModel2.id);
+  if (fallback && runtime.hasConfiguredAuth(fallback.provider))
+    return correctInputs(fallback);
+  return correctInputs((await runtime.getAvailable())[0]);
+};
+var akanCodeModelSupportsImages2 = (model) => !!model?.input.includes("image");
+var akanCodeModelWarnings2 = (model, compactionFloor) => {
+  if (!model)
+    return [];
+  if (model.contextWindow >= compactionFloor)
+    return [];
+  return [
+    `${model.provider}/${model.id} declares a ${model.contextWindow}-token context window, below the ${compactionFloor} the compaction policy needs, so every turn will compact immediately. Check the model entry in ~/.akan/code/models.json.`
+  ];
+};
+
+// pkgs/@akanjs/devkit/codeAgent/agent/CodeAgentStreamPrinter.ts
+import { codeAgentEventLabel } from "akanjs/common";
+import chalk from "chalk";
+
+class CodeAgentStreamPrinter2 {
+  #options;
+  #write;
+  #streaming = false;
+  constructor(options = {}) {
+    this.#options = options;
+    this.#write = options.write ?? ((text) => process.stdout.write(text));
+  }
+  print(event) {
+    if (this.#options.json)
+      return this.#write(`${JSON.stringify(event)}
+`);
+    switch (event.type) {
+      case "text_delta":
+        this.#streaming = true;
+        return this.#write(event.text);
+      case "thinking_delta":
+        if (!this.#options.thinking)
+          return;
+        this.#streaming = true;
+        return this.#write(chalk.dim(event.text));
+      case "tool_start":
+        return this.#line(chalk.cyan(`\u2192 ${event.tool.title}`));
+      case "tool_end":
+        return this.#line(CodeAgentStreamPrinter2.#toolEnd(event));
+      case "session":
+        return this.#line(chalk.dim(codeAgentEventLabel(event)));
+      case "turn_end":
+        if (event.stopReason === "truncated")
+          return this.#line(chalk.yellow(codeAgentEventLabel(event)));
+        return;
+      case "message":
+      case "tool_progress":
+      case "turn_start":
+      case "idle":
+      case "queue":
+      case "context":
+      case "subagent":
+        return;
+      case "question":
+        return this.#line(chalk.yellow(`? ${event.question.prompt}`));
+      case "approval":
+        return this.#line(chalk.yellow(`approve? ${event.request.summary}`));
+      case "notice":
+        return this.#line(CodeAgentStreamPrinter2.#notice(event.level, event.message));
+      case "error":
+        return this.#line(chalk.red(`error: ${event.message}`));
+      default:
+        return this.#line(chalk.dim(codeAgentEventLabel(event)));
+    }
+  }
+  finish() {
+    if (this.#streaming)
+      this.#write(`
+`);
+    this.#streaming = false;
+  }
+  #line(text) {
+    if (this.#streaming)
+      this.#write(`
+`);
+    this.#streaming = false;
+    this.#write(`${text}
+`);
+  }
+  static #toolEnd(event) {
+    if (event.outcome === "ok")
+      return chalk.green(`\u2713 ${event.tool.title}`);
+    if (event.outcome === "blocked")
+      return chalk.yellow(`\u29B8 ${event.tool.title} \u2014 ${event.output}`);
+    return chalk.red(`\u2717 ${event.tool.title} \u2014 ${event.output.split(`
+`)[0] ?? ""}`);
+  }
+  static #notice(level, message) {
+    if (level === "error")
+      return chalk.red(message);
+    if (level === "warning")
+      return chalk.yellow(message);
+    return chalk.dim(message);
+  }
+}
+
+export { akanCodeDefaultModel2, akanCodeModel2, akanCodeModelSupportsImages2, akanCodeModelWarnings2, CodeAgentStreamPrinter2 };

package/index-d2242ksy.js

@@ -0,0 +1,99 @@
+// @bun
+// pkgs/@akanjs/devkit/codeAgent/agent/CodeAgentRpcHost.ts
+class CodeAgentRpcHost2 {
+  #agent;
+  #write;
+  #buffer = "";
+  #started = false;
+  #resolveShutdown = () => {};
+  shutdown = new Promise((resolve) => {
+    this.#resolveShutdown = resolve;
+  });
+  constructor(agent, write = (line) => process.stdout.write(line)) {
+    this.#agent = agent;
+    this.#write = write;
+  }
+  async serve(input = process.stdin) {
+    this.start();
+    const decoder = new TextDecoder;
+    for await (const chunk of input)
+      await this.feed(decoder.decode(chunk, { stream: true }));
+    await this.#agent.abort().catch(() => {});
+  }
+  start() {
+    if (this.#started)
+      return;
+    this.#started = true;
+    this.#agent.on((event) => this.#emit(event));
+    this.#agent.announce();
+  }
+  attach(write) {
+    this.#write = write;
+    this.#buffer = "";
+  }
+  async feed(text) {
+    this.#buffer += text;
+    let index = this.#buffer.indexOf(`
+`);
+    while (index >= 0) {
+      const line = this.#buffer.slice(0, index).trim();
+      this.#buffer = this.#buffer.slice(index + 1);
+      if (line)
+        await this.#handle(line);
+      index = this.#buffer.indexOf(`
+`);
+    }
+  }
+  async#handle(line) {
+    let request;
+    try {
+      request = JSON.parse(line);
+    } catch {
+      return this.#emit({ type: "error", message: "malformed command frame", fatal: false, seq: -1 });
+    }
+    try {
+      this.#reply({ type: "reply", id: request.id, ok: true, data: await this.#run(request.command) });
+    } catch (error) {
+      this.#reply({ type: "reply", id: request.id, ok: false, error: String(error) });
+    }
+    if (request.command?.type === "shutdown")
+      this.#resolveShutdown();
+  }
+  async#run(command) {
+    switch (command.type) {
+      case "prompt":
+        this.#agent.prompt(command.message, command.images);
+        return { accepted: true };
+      case "answer":
+        return { handled: await this.#agent.answer(command.questionId, command.answer) };
+      case "approve":
+        return { handled: await this.#agent.approve(command.approvalId, command.approved) };
+      case "abort":
+        await this.#agent.abort();
+        return { aborted: true };
+      case "compact":
+        await this.#agent.compact(command.instructions);
+        return { compacted: true };
+      case "set_model":
+        await this.#agent.setModel({ provider: command.provider, id: command.modelId });
+        return await this.#agent.state();
+      case "get_state":
+        return await this.#agent.state(command.sinceSeq === undefined ? {} : { sinceSeq: command.sinceSeq });
+      case "shutdown":
+        this.#agent.dispose();
+        return { shutdown: true };
+      default:
+        throw new Error(`Unsupported command: ${command.type}`);
+    }
+  }
+  #emit(event) {
+    this.#write?.(`${JSON.stringify({ type: "event", event })}
+`);
+  }
+  #reply(reply) {
+    this.#write?.(`${JSON.stringify(reply)}
+`);
+  }
+}
+
+export { CodeAgentRpcHost2 };