@akanjs/devkit 3.0.0-beta.12 → 3.0.0-beta.14

package/cloud/cloudApi.ts

@@ -2,6 +2,11 @@ import type { Workspace } from "../commandDecorators";
 import type { AccessToken, AccessTokenDto, HostConfig } from "./constants";
 import { GlobalConfig } from "./globalConfig";
 
+interface HttpRequestOptions {
+  headers?: Record<string, string>;
+  signal?: AbortSignal;
+}
+
 class HttpClient {
   readonly baseUrl: string;
   readonly headers: Record<string, string> = {};
@@ -9,15 +14,16 @@ class HttpClient {
     this.baseUrl = baseUrl;
     this.headers = headers;
   }
-  async get<T>(url: string, { headers }: { headers?: Record<string, string> } = {}): Promise<T> {
+  async get<T>(url: string, { headers, signal }: HttpRequestOptions = {}): Promise<T> {
     const response = await fetch(`${this.baseUrl}${url}`, {
       headers: {
         "Content-Type": "application/json",
         ...this.headers,
         ...headers,
       },
+      ...(signal ? { signal } : {}),
     });
-    return await response.json();
+    return await HttpClient.#body<T>(response, url);
   }
   async getFile(url: string, localPath: string, headers?: Record<string, string>): Promise<void> {
     const response = await fetch(`${this.baseUrl}${url}`, {
@@ -26,7 +32,7 @@ class HttpClient {
     if (!response.ok) throw new Error(`Failed to download file: ${response.status} ${response.statusText}`);
     await Bun.write(localPath, response);
   }
-  async post<T>(url: string, data: unknown, { headers }: { headers?: Record<string, string> } = {}): Promise<T> {
+  async post<T>(url: string, data: unknown, { headers, signal }: HttpRequestOptions = {}): Promise<T> {
     const isFormData = data instanceof FormData;
     const response = await fetch(`${this.baseUrl}${url}`, {
       method: "POST",
@@ -34,8 +40,18 @@ class HttpClient {
       headers: isFormData
         ? { ...this.headers, ...headers }
         : { "Content-Type": "application/json", ...this.headers, ...headers },
+      ...(signal ? { signal } : {}),
     });
-    return await response.json();
+    return await HttpClient.#body<T>(response, url);
+  }
+  /**
+   * A route that does not exist answers the error *page*, not JSON, so parsing first reports a syntax error at
+   * `<` and buries the status that says what is actually wrong. Read the status before the body.
+   */
+  static async #body<T>(response: Response, url: string): Promise<T> {
+    const text = await response.text();
+    if (!response.ok) throw new Error(`${response.status} ${response.statusText} from ${url}: ${text.slice(0, 200)}`);
+    return JSON.parse(text) as T;
   }
   setHeaders(headers: Record<string, string>) {
     Object.assign(this.headers, headers);
@@ -132,16 +148,27 @@ export class CloudApi {
     this.#api.setHeaders({ Authorization: `Bearer ${this.#accessToken.jwt}` });
     return this.#accessToken;
   }
+  /**
+   * The `/tunnel` segment is the model's refName, which every database module's endpoints carry and the service
+   * modules above — `_cloud`, which owns `uploadEnv` and `getRemoteSelf` — do not. Dropping it to match those
+   * neighbours answers 404, and the control plane returns an HTML error page that fails as a JSON parse error.
+   */
   async requestTunnel(input: { name: string; ttlMinutes?: number }): Promise<TunnelGrant> {
-    return await this.#api.post<TunnelGrant>(`/requestTunnel`, input);
+    return await this.#api.post<TunnelGrant>(`/tunnel/requestTunnel`, input);
   }
   /** The generated name of the model's own `inSelf` slice: a hand-written `listTunnels` would collide with it. */
   async tunnelListInSelf(): Promise<TunnelSummary[]> {
-    return await this.#api.get<TunnelSummary[]>(`/tunnelListInSelf`);
-  }
-  /** Hands the grant back. The CLI calls this "stop", which is what the operator is doing, not what it does. */
+    return await this.#api.get<TunnelSummary[]>(`/tunnel/tunnelListInSelf`);
+  }
+  /**
+   * Hands the grant back. The CLI calls this "stop", which is what the operator is doing, not what it does.
+   *
+   * Bounded because every caller is on the way out: an unreachable control plane is exactly the state a session
+   * ends in, and an unbounded `fetch` there holds the event loop open long after the work is done. Losing the
+   * release costs nothing — the share expires on its own TTL.
+   */
   async revokeTunnel(code: string): Promise<boolean> {
-    return await this.#api.post<boolean>(`/revokeTunnel`, { code });
+    return await this.#api.post<boolean>(`/tunnel/revokeTunnel`, { code }, { signal: AbortSignal.timeout(5_000) });
   }
   async getRemoteSelf(): Promise<{ id: string; nickname: string } | null> {
     try {

package/cloud/constants.ts

@@ -1,5 +1,4 @@
 import type { Dayjs } from "dayjs";
-import type { SupportedLlmModel } from "../aiEditor";
 import { GlobalConfig } from "./globalConfig";
 
 export const basePath = `${Bun.env.HOME ?? Bun.env.USERPROFILE}/.akan`;
@@ -28,12 +27,10 @@ export interface RemoteEnvServerConfig {
 export interface AkanGlobalConfig {
   cloudHost: { [key: string]: HostConfigDto };
   remoteEnvServers: Record<string, RemoteEnvServerConfig>;
-  llm: { model: SupportedLlmModel; apiKey: string } | null;
 }
 export const defaultAkanGlobalConfig: AkanGlobalConfig = {
   cloudHost: {},
   remoteEnvServers: {},
-  llm: null,
 };
 
 export interface AccessTokenDto {

package/cloud/globalConfig.ts

@@ -30,7 +30,7 @@ export class GlobalConfig {
     };
   }
   /**
-   * This file holds the cloud jwt, a refresh token that does not expire, and the LLM api key, so it is
+   * This file holds the cloud jwt and a refresh token that does not expire, so it is
    * written owner-only — the same `0600` the runtime gives its control socket. `Bun.write` takes no mode
    * and lands on `0666 & ~umask` (0644 on a default shell), so the mode is applied after the write; an
    * existing world-readable file is tightened by the next write rather than left as it was found.
@@ -49,14 +49,6 @@ export class GlobalConfig {
     akanConfig.cloudHost[config.host] = GlobalConfig.toHostConfigDto(config);
     await GlobalConfig.#setAkanGlobalConfig(akanConfig);
   }
-  static async getLlmConfig(): Promise<AkanGlobalConfig["llm"]> {
-    const akanConfig = await GlobalConfig.#getAkanGlobalConfig();
-    return akanConfig.llm ?? null;
-  }
-  static async setLlmConfig(llmConfig: AkanGlobalConfig["llm"]) {
-    const akanConfig = await GlobalConfig.#getAkanGlobalConfig();
-    await GlobalConfig.#setAkanGlobalConfig({ ...akanConfig, llm: llmConfig });
-  }
   static async getRemoteEnvServers(): Promise<AkanGlobalConfig["remoteEnvServers"]> {
     const akanConfig = await GlobalConfig.#getAkanGlobalConfig();
     return akanConfig.remoteEnvServers;

package/commandDecorators/command.ts

@@ -11,7 +11,7 @@ import { type Command, program } from "commander";
 import { AppSelectionMemory } from "../appSelectionMemory";
 import { AppExecutor, Executor, LibExecutor, ModuleExecutor, PkgExecutor, WorkspaceExecutor } from "../executors";
 // Import the owning modules directly, never the root barrel: `..` re-exports all 41 devkit modules,
-// so a barrel import here drags ink, @trapezedev/project, ssh2, @langchain/* and the cloud stack into
+// so a barrel import here drags ink, @trapezedev/project, ssh2 and the cloud stack into
 // every process that registers a command (measured: 236MB vs 3MB).
 import { FileSys } from "../fileSys";
 import { getDirname } from "../getDirname";

package/incrementalBuilder/incrementalBuilder.proc.ts

@@ -1,6 +1,6 @@
 import path from "node:path";
 // Module paths, never a barrel. The `@akanjs/devkit` root re-exports all 41 modules, which would drag
-// @trapezedev/project, the @langchain stack, ssh2, ink and the cloud stack in; and `frontendBuild`'s own
+// @trapezedev/project, ssh2, ink and the cloud stack in; and `frontendBuild`'s own
 // barrel reaches `cssCompiler`/`ssrBaseArtifactBuilder`, which pull tailwindcss + @tailwindcss/node
 // (~40MB) into a process that then holds them for the whole dev session. Phase 2 moved css compilation
 // into the batch worker, so this process has no use for them — `entryModuleGraph.test.ts` keeps it that way.

package/index.ts

@@ -1,7 +1,7 @@
 // Types only, deliberately. This barrel re-exports all 40 devkit facets, so a single *value* import
 // from it loads every one of them — measured at 417MB / 654ms, versus 38MB / 38ms for the one subpath
 // the caller actually needed. That is how `commandDecorators/command.ts` silently put ink, typescript,
-// ssh2, @trapezedev/project, @langchain/* and the cloud stack into every process that registered a CLI
+// ssh2, @trapezedev/project and the cloud stack into every process that registered a CLI
 // command, and it is the single largest regression this package can suffer from a one-line edit.
 //
 // `export type *` erases at runtime (verified on Bun 1.3.14: the re-exported module is never loaded),
@@ -12,7 +12,6 @@
 //
 // Import values from the owning facet instead: `import { FileSys } from "@akanjs/devkit/fileSys"`.
 // Keep this file type-only; do not "fix" a TS1362 by widening an entry back to `export *`.
-export type * from "./aiEditor";
 export type * from "./akanApp";
 export type * from "./akanConfig";
 export type * from "./akanContext";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "3.0.0-beta.12",
+  "version": "3.0.0-beta.14",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -39,12 +39,9 @@
   },
   "dependencies": {
     "@inquirer/prompts": "^8.4.3",
-    "@langchain/core": "^1.1.47",
-    "@langchain/deepseek": "^1.0.26",
-    "@langchain/openai": "^1.4.6",
     "@tailwindcss/node": "^4.3.0",
     "@trapezedev/project": "^7.1.4",
-    "akanjs": "3.0.0-beta.12",
+    "akanjs": "3.0.0-beta.14",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "dayjs": "^1.11.20",

package/abstractCompactor.ts

@@ -1,112 +0,0 @@
-import { Logger } from "akanjs/common";
-import chalk from "chalk";
-import { AbstractDoc, type AbstractKind } from "./abstractDoc";
-import { AiSession } from "./aiEditor";
-import type { SysExecutor } from "./executors";
-
-export interface AbstractCompactOptions {
-  module?: string | null;
-  minLines?: number;
-  interactive?: boolean;
-}
-
-export interface AbstractCompactReport {
-  path: string;
-  beforeLines: number;
-  afterLines: number;
-  status: "compacted" | "unchanged" | "failed";
-}
-
-/** Rewrites bloated `*.abstract.md` files down to the invariants their source files cannot show. */
-export class AbstractCompactor {
-  static readonly #reviewRequest = `Review the compacted file you just wrote against the original.
-- Did you drop an invariant, a security reason, or a workflow step that the source files cannot show by themselves? Restore it.
-- Did you keep anything that only restates code, scaffold wording, or history? Remove it.
-- Is it in the same language as the original, within the line budget, and one short line per bullet?
-Respond with exactly one \`\`\`markdown code block holding the corrected file and nothing else. If nothing needs to change, repeat the file unchanged.`;
-
-  #sys: SysExecutor;
-  #minLines: number;
-  #interactive: boolean;
-  constructor(
-    sys: SysExecutor,
-    { minLines = AbstractDoc.compactMinLines, interactive = false }: AbstractCompactOptions = {},
-  ) {
-    this.#sys = sys;
-    this.#minLines = minLines;
-    this.#interactive = interactive;
-  }
-  async compactAll({ module }: { module?: string | null } = {}) {
-    const docs = await AbstractDoc.findAll(this.#sys, { module });
-    const targets = docs.filter((doc) => doc.lineCount > this.#minLines);
-    const reports: AbstractCompactReport[] = [];
-    // One file at a time: each doc gets its own AI session, and parallel runs would interleave the
-    // streamed response with each other and with the interactive confirm prompt.
-    for (const doc of targets) reports.push(await this.compact(doc));
-    return { scanned: docs.length, reports };
-  }
-  async compact(doc: AbstractDoc): Promise<AbstractCompactReport> {
-    const session = new AiSession("compactAbstract", {
-      workspace: this.#sys.workspace,
-      cacheKey: `${this.#sys.name}-${doc.moduleName}`,
-    });
-    const approve = !this.#interactive;
-    const compacted = await session.editMarkdown(this.#request(doc), { approve });
-    const reviewed = await session.editMarkdown(AbstractCompactor.#reviewRequest, { approve });
-    // The review answers in prose when it finds nothing to fix, so the first compaction is the fallback.
-    const next = [reviewed, compacted]
-      .map((candidate) => candidate.trim())
-      .find((candidate) => doc.canReplaceWith(candidate));
-    const beforeLines = doc.lineCount;
-    if (!next) {
-      Logger.rawLog(chalk.yellow(`${doc.path}: the editor returned no shorter abstract, keeping the current file`));
-      return { path: doc.path, beforeLines, afterLines: beforeLines, status: "failed" };
-    }
-    if (next === doc.content.trim())
-      return { path: doc.path, beforeLines, afterLines: beforeLines, status: "unchanged" };
-    const content = `${next}\n`;
-    await this.#sys.writeFile(doc.path, content);
-    return { path: doc.path, beforeLines, afterLines: AbstractDoc.lineCountOf(content), status: "compacted" };
-  }
-  #targetShape(kind: AbstractKind) {
-    if (kind === "other")
-      return "  - keep the headings that still carry information and drop the rest; do not impose a new structure";
-    return [
-      "  - `# <name> Abstract` title line",
-      "  - one declarative sentence naming what this module owns",
-      "  - `## Rules` — two to five bullets, each an invariant the code cannot show by itself",
-      "  - optional `## Workflow` — the lifecycle as an arrow chain (`draft -> signed -> active`) or a few bullets",
-    ].join("\n");
-  }
-  #request(doc: AbstractDoc) {
-    return `You are compacting an Akan.js abstract file.
-
-An abstract is the summary a coding agent reads before changing a module. Repeated edits have made this one
-bloated, and it has to shrink back to what the source files cannot show by themselves.
-
-# Target file
-${this.#sys.type}s/${this.#sys.name}/${doc.path} (${doc.kind} module "${doc.moduleName}", ${doc.lineCount} lines)
-
-# Source files in the same folder
-${doc.siblingFiles.join(", ") || "none"}
-
-# Current content
-\`\`\`markdown
-${doc.content}
-\`\`\`
-
-# Rules for the compacted file
-- Write it in the SAME language as the current content. Never translate.
-- Keep every invariant, constraint, security reason, and workflow step that the source files cannot show by
-  themselves. Merge duplicates instead of dropping either one.
-- Delete what the code already states: field lists, types, labels, signatures, file lists, and imports.
-- Delete scaffold and placeholder wording, changelog or migration history, TODOs, and any instruction about
-  reading or updating this file.
-- Never invent a rule that the current content does not state.
-- Keep every bullet to one short line, and stay under ${AbstractDoc.compactMinLines} lines in total.
-- Shape:
-${this.#targetShape(doc.kind)}
-
-Respond with exactly one \`\`\`markdown code block holding the whole new file and nothing else.`;
-  }
-}

package/aiEditor.test.ts

@@ -1,60 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { parseTypescriptFileBlocks, preserveTypescriptResponseContent } from "./aiEditor";
-
-describe("parseTypescriptFileBlocks", () => {
-  test("parses TypeScript file blocks with common fence variants", () => {
-    const writes = parseTypescriptFileBlocks(`
-\`\`\`ts
-
-// File: lib/car/car.constant.ts
-
-export const car = "car";
-\`\`\`
-
-\`\`\`tsx
-  // File: lib/car/Car.Unit.tsx
-export const CarUnit = () => null;
-\`\`\`
-`);
-
-    expect(writes).toEqual([
-      {
-        filePath: "lib/car/car.constant.ts",
-        content: 'export const car = "car";',
-      },
-      {
-        filePath: "lib/car/Car.Unit.tsx",
-        content: "export const CarUnit = () => null;",
-      },
-    ]);
-  });
-
-  test("keeps previous code response when validation responds with prose only", () => {
-    const previousContent = `
-\`\`\`typescript
-// File: lib/car/car.constant.ts
-export const car = "car";
-\`\`\`
-`;
-    const nextContent = "The generated file meets all specified requirements. No rewrite is necessary.";
-
-    expect(preserveTypescriptResponseContent(previousContent, nextContent)).toBe(previousContent);
-  });
-
-  test("uses next code response when validation rewrites with parseable files", () => {
-    const previousContent = `
-\`\`\`typescript
-// File: lib/car/car.constant.ts
-export const car = "car";
-\`\`\`
-`;
-    const nextContent = `
-\`\`\`typescript
-// File: lib/car/car.constant.ts
-export const car = "updated";
-\`\`\`
-`;
-
-    expect(preserveTypescriptResponseContent(previousContent, nextContent)).toBe(nextContent);
-  });
-});

package/aiEditor.ts

@@ -1,387 +0,0 @@
-import { input, select } from "@inquirer/prompts";
-import {
-  AIMessage,
-  type BaseMessage,
-  HumanMessage,
-  mapChatMessagesToStoredMessages,
-  mapStoredMessagesToChatMessages,
-  type StoredMessage,
-} from "@langchain/core/messages";
-import { ChatDeepSeek } from "@langchain/deepseek";
-import { ChatOpenAI } from "@langchain/openai";
-import { Logger } from "akanjs/common";
-import chalk from "chalk";
-
-import { GlobalConfig } from "./cloud";
-import type { Executor, WorkspaceExecutor } from "./executors";
-import { Spinner } from "./spinner";
-import type { FileContent } from "./types";
-
-const MAX_ASK_TRY = 300;
-
-const deepSeekLlmModels = ["deepseek-v4-flash", "deepseek-v4-pro"] as const;
-
-const openAiLlmModels = ["gpt-5.5"] as const;
-
-export const supportedLlmModels = [...deepSeekLlmModels, ...openAiLlmModels] as const;
-export type SupportedLlmModel = (typeof supportedLlmModels)[number];
-type OpenAiLlmModel = (typeof openAiLlmModels)[number];
-
-const isOpenAiLlmModel = (model: SupportedLlmModel): model is OpenAiLlmModel =>
-  openAiLlmModels.includes(model as OpenAiLlmModel);
-
-interface EditOptions {
-  onReasoning?: (reasoning: string) => void;
-  onChunk?: (chunk: string) => void;
-  maxTry?: number;
-  validate?: string[];
-  approve?: boolean;
-  fallbackToPreviousTypescript?: boolean;
-}
-
-export const parseTypescriptFileBlocks = (text: string): FileContent[] => {
-  const fileBlocks: FileContent[] = [];
-  const codeBlockRegex = /```(?:typescript|ts|tsx)\s*\n([\s\S]*?)```/gi;
-  const filePathRegex = /^\s*\/\/\s*File:\s*(.+?)\s*$/im;
-
-  for (const codeBlock of text.matchAll(codeBlockRegex)) {
-    const content = codeBlock[1]?.trim();
-    if (!content) continue;
-
-    const filePath = filePathRegex.exec(content)?.[1]?.trim();
-    if (!filePath) continue;
-
-    fileBlocks.push({
-      filePath,
-      content: content.replace(filePathRegex, "").trim(),
-    });
-  }
-
-  return fileBlocks;
-};
-
-export const preserveTypescriptResponseContent = (previousContent: string, nextContent: string) => {
-  const previousWrites = parseTypescriptFileBlocks(previousContent);
-  const nextWrites = parseTypescriptFileBlocks(nextContent);
-  if (previousWrites.length > 0 && nextWrites.length === 0) return previousContent;
-  return nextContent;
-};
-
-export class AiSession {
-  static #cacheDir = "node_modules/.cache/akan/aiSession";
-  static #chat: ChatDeepSeek | ChatOpenAI | null = null;
-  static async init({ temperature = 0, useExisting = true }: { temperature?: number; useExisting?: boolean } = {}) {
-    if (useExisting) {
-      const llmConfig = await AiSession.getLlmConfig();
-      if (llmConfig) {
-        AiSession.#setChatModel(llmConfig.model, llmConfig.apiKey);
-        Logger.rawLog(chalk.dim(`🤖akan editor uses existing LLM config (${llmConfig.model})`));
-        return AiSession;
-      }
-    } else Logger.rawLog(chalk.yellow("🤖akan-editor is not initialized. LLM configuration should be set first."));
-
-    const llmConfig = await AiSession.#requestLlmConfig();
-    const { model, apiKey } = llmConfig;
-
-    await AiSession.#validateApiKey(model, apiKey);
-    const session = AiSession.#setChatModel(model, apiKey, { temperature });
-    await session.setLlmConfig({ model, apiKey });
-    return session;
-  }
-  static #setChatModel(model: SupportedLlmModel, apiKey: string, { temperature = 0 }: { temperature?: number } = {}) {
-    AiSession.#chat = AiSession.#createChatModel(model, apiKey, {
-      temperature,
-      streaming: true,
-    });
-    return AiSession;
-  }
-  static #createChatModel(
-    model: SupportedLlmModel,
-    apiKey: string,
-    { temperature = 0, streaming = false }: { temperature?: number; streaming?: boolean } = {},
-  ) {
-    if (isOpenAiLlmModel(model))
-      return new ChatOpenAI({
-        modelName: model,
-        temperature,
-        streaming,
-        openAIApiKey: apiKey,
-      });
-    return new ChatDeepSeek({
-      modelName: model,
-      temperature,
-      streaming,
-      apiKey,
-    });
-  }
-  static async getLlmConfig() {
-    return await GlobalConfig.getLlmConfig();
-  }
-  static async setLlmConfig(llmConfig: { model: SupportedLlmModel; apiKey: string } | null) {
-    await GlobalConfig.setLlmConfig(llmConfig);
-    return AiSession;
-  }
-  static async #requestLlmConfig() {
-    const model = await select<SupportedLlmModel>({
-      message: "Select a LLM model",
-      choices: supportedLlmModels,
-    });
-    const apiKey = await input({ message: "Enter your API key" });
-    return { model, apiKey };
-  }
-  static async #validateApiKey(modelName: SupportedLlmModel, apiKey: string) {
-    const spinner = new Spinner("Validating LLM API key...", {
-      prefix: `🤖akan-editor`,
-    }).start();
-    const chat = AiSession.#createChatModel(modelName, apiKey);
-    try {
-      await chat.invoke("Hi, and just say 'ok'");
-      spinner.succeed("LLM API key is valid");
-      return true;
-    } catch (error) {
-      spinner.fail(
-        chalk.red(
-          `LLM API key is invalid. Please check your API key and try again. You can set it again by running "akan set-llm" or reset by running "akan reset-llm"`,
-        ),
-      );
-      throw error;
-    }
-  }
-  static async clearCache(workspaceRoot: string) {
-    const cacheDir = `${workspaceRoot}/${AiSession.#cacheDir}`;
-    await Bun.$`rm -rf ${cacheDir}`;
-  }
-
-  messageHistory: BaseMessage[] = [];
-  readonly sessionKey: string;
-  isCacheLoaded: boolean = false;
-  workspace: WorkspaceExecutor;
-  constructor(
-    type: string,
-    {
-      workspace,
-      cacheKey,
-      isContinued,
-    }: {
-      workspace: WorkspaceExecutor;
-      cacheKey?: string;
-      isContinued?: boolean;
-    },
-  ) {
-    this.workspace = workspace;
-    this.sessionKey = `${type}${cacheKey ? `-${cacheKey}` : ""}`;
-    if (isContinued) this.#cacheLoadPromise = this.#loadCache();
-  }
-  #cacheLoadPromise: Promise<void> | null = null;
-  async #loadCache() {
-    const cacheFile = `${AiSession.#cacheDir}/${this.sessionKey}.json`;
-    const isCacheExists = await this.workspace.exists(cacheFile);
-    if (isCacheExists)
-      this.messageHistory = mapStoredMessagesToChatMessages(
-        (await this.workspace.readJson(cacheFile)) as StoredMessage[],
-      );
-    else this.messageHistory = [];
-    this.isCacheLoaded = isCacheExists;
-  }
-  async #saveCache() {
-    const cacheFilePath = `${AiSession.#cacheDir}/${this.sessionKey}.json`;
-    await this.workspace.writeJson(cacheFilePath, mapChatMessagesToStoredMessages(this.messageHistory));
-  }
-  async ask(
-    question: string,
-    {
-      onReasoning = (reasoning: string) => {
-        Logger.raw(chalk.dim(reasoning));
-      },
-      onChunk = (chunk: string) => {
-        Logger.raw(chunk);
-      },
-    }: EditOptions = {},
-  ): Promise<{ content: string; messageHistory: BaseMessage[] }> {
-    if (!AiSession.#chat) await AiSession.init();
-    if (this.#cacheLoadPromise) await this.#cacheLoadPromise;
-
-    if (!AiSession.#chat) throw new Error("Failed to initialize the AI session");
-    const loader = new Spinner(`${AiSession.#chat.model} is thinking...`, {
-      prefix: `🤖akan-editor`,
-    }).start();
-    try {
-      const humanMessage = new HumanMessage(question);
-      this.messageHistory.push(humanMessage);
-      const stream = await AiSession.#chat.stream(this.messageHistory);
-      let reasoningResponse = "",
-        fullResponse = "";
-      for await (const chunk of stream) {
-        if (loader.isSpinning()) loader.succeed(`${AiSession.#chat.model} responded`);
-
-        if (!fullResponse.length) {
-          const reasoningContent = (chunk.additional_kwargs as { reasoning_content?: string }).reasoning_content ?? "";
-          if (reasoningContent.length) {
-            reasoningResponse += reasoningContent;
-            onReasoning(reasoningContent);
-            continue;
-          } else if (chunk.content.length) {
-            reasoningResponse += "\n";
-            onReasoning(reasoningResponse);
-          }
-        }
-
-        const content = chunk.content;
-        if (typeof content === "string") {
-          fullResponse += content;
-          onChunk(content); // Send individual chunks to callback
-        }
-      }
-      fullResponse += "\n";
-      onChunk("\n");
-      this.messageHistory.push(new AIMessage(fullResponse));
-      return { content: fullResponse, messageHistory: this.messageHistory };
-    } catch {
-      loader.fail(`${AiSession.#chat.model} failed to respond`);
-      throw new Error("Failed to stream response");
-    }
-  }
-  async edit(
-    question: string,
-    { onChunk, onReasoning, maxTry = MAX_ASK_TRY, validate, approve, fallbackToPreviousTypescript }: EditOptions = {},
-  ) {
-    for (let tryCount = 0; tryCount < maxTry; tryCount++) {
-      let response = await this.ask(question, { onChunk, onReasoning });
-      if (validate?.length && tryCount === 0) {
-        const validateQuestion = `Double check if the response meets the requirements and conditions, and follow the instructions. If not, rewrite it.
-${validate.map((v) => `- ${v}`).join("\n")}`;
-        const validateResponse = await this.ask(validateQuestion, {
-          onChunk,
-          onReasoning,
-        });
-        response = {
-          ...validateResponse,
-          content: fallbackToPreviousTypescript
-            ? preserveTypescriptResponseContent(response.content, validateResponse.content)
-            : validateResponse.content,
-        };
-      }
-      const isConfirmed = approve
-        ? true
-        : await select({
-            message: "Do you want to edit the response?",
-            choices: [
-              { name: "✅ Yes, confirm and apply this result", value: true },
-              { name: "🔄 No, I want to edit it more", value: false },
-            ],
-          });
-      if (isConfirmed) {
-        await this.#saveCache();
-        return response.content;
-      }
-      question = await input({ message: "What do you want to change?" });
-      tryCount++;
-    }
-    throw new Error("Failed to edit");
-  }
-  async editTypescript(question: string, options: EditOptions = {}) {
-    const content = await this.edit(question, options);
-    return this.#getTypescriptCode(content);
-  }
-  #getTypescriptCode(content: string) {
-    //! will be deprecated
-    const code = /```(typescript|tsx)([\s\S]*?)```/.exec(content);
-    // 2번째로 해야 반환되는데 모르겟음 아무튼 일단 이렇게 함.
-
-    return code?.[2] ?? content;
-    // return code ? code[1] : content;
-  }
-  addToolMessgaes(messages: { type: string; content: string }[]) {
-    // const toolMessages = messages.map(
-    //   (message) => new ToolMessage({ content: message.content, tool_call_id: message.type })
-    // );
-    const toolMessages = messages.map((message) => new HumanMessage(message.content));
-    this.messageHistory.push(...toolMessages);
-    return this;
-  }
-  async writeTypescripts(question: string, executor: Executor, options: EditOptions = {}) {
-    const content = await this.edit(question, {
-      ...options,
-      fallbackToPreviousTypescript: true,
-    });
-    const writes = this.#getTypescriptCodes(content);
-    if (!writes.length)
-      throw new Error(
-        "No parseable TypeScript file blocks were found in the AI response. Include `// File: <path>` in each code block.",
-      );
-    for (const write of writes) await executor.writeFile(write.filePath, write.content);
-    return await this.#tryFixTypescripts(writes, executor, options);
-  }
-  async #editTypescripts(question: string, options: EditOptions = {}, fallbackWrites?: FileContent[]) {
-    const content = await this.edit(question, {
-      ...options,
-      fallbackToPreviousTypescript: true,
-    });
-    const writes = this.#getTypescriptCodes(content);
-    if (!writes.length && fallbackWrites?.length) return fallbackWrites;
-    if (!writes.length)
-      throw new Error(
-        "No parseable TypeScript file blocks were found in the AI response. Include `// File: <path>` in each code block.",
-      );
-    return writes;
-  }
-  async #tryFixTypescripts(writes: FileContent[], executor: Executor, options: EditOptions = {}) {
-    const MAX_EDIT_TRY = 5;
-    for (let tryCount = 0; tryCount < MAX_EDIT_TRY; tryCount++) {
-      const loader = new Spinner(`Type checking and linting...`, {
-        prefix: `🤖akan-editor`,
-      }).start();
-      const fileChecks = await Promise.all(
-        writes.map(async ({ filePath }) => {
-          const lintResult = await executor.lint(filePath, { fix: true });
-          const typeCheckResult = await executor.typeCheckAsync(filePath);
-          const hasTypeErrors = typeCheckResult.fileErrors.length > 0;
-          const hasLintErrors = lintResult.errors.length > 0;
-          const needFix = hasTypeErrors || hasLintErrors;
-          return { filePath, typeCheckResult, lintResult, needFix };
-        }),
-      );
-      const hasAnyFix = fileChecks.some((fileCheck) => fileCheck.needFix);
-      if (hasAnyFix) {
-        loader.fail("Type checking and linting has some errors, try to fix them");
-        fileChecks.forEach((fileCheck) => {
-          Logger.rawLog(
-            `TypeCheck Result \n${fileCheck.typeCheckResult.message}\nLint Result \n${fileCheck.lintResult.message}`,
-          );
-          this.addToolMessgaes([
-            { type: "typescript", content: fileCheck.typeCheckResult.message },
-            { type: "eslint", content: fileCheck.lintResult.message },
-          ]);
-        });
-        writes = await this.#editTypescripts(
-          "Fix the typescript and eslint errors",
-          {
-            ...options,
-            validate: undefined,
-            approve: true,
-          },
-          writes,
-        );
-        for (const write of writes) await executor.writeFile(write.filePath, write.content);
-      } else {
-        loader.succeed("Type checking and linting has no errors");
-        return writes;
-      }
-    }
-    throw new Error("Failed to create scalar");
-  }
-  #getTypescriptCodes(text: string): FileContent[] {
-    return parseTypescriptFileBlocks(text);
-  }
-  async editMarkdown(request: string, options: EditOptions = {}) {
-    const content = await this.edit(request, options);
-    return this.#getMarkdownContent(content);
-  }
-  #getMarkdownContent(text: string) {
-    const searchText = "```markdown";
-    const firstIndex = text.indexOf("```markdown");
-    const lastIndex = text.lastIndexOf("```");
-    if (firstIndex === -1) return text;
-    else return text.slice(firstIndex + searchText.length, lastIndex).trim();
-  }
-}