akanjs 2.0.7 → 2.1.0-rc.1

package/cli/testHelpers.ts

@@ -1,171 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { AppExecutor, LibExecutor, ModuleExecutor, PkgExecutor, WorkspaceExecutor } from "akanjs/devkit";
-
-export interface CallRecord {
-  name: string;
-  args: unknown[];
-}
-
-export const createCallRecorder = () => {
-  const calls: CallRecord[] = [];
-  return {
-    calls,
-    record(name: string, ...args: unknown[]) {
-      calls.push({ name, args });
-    },
-    names() {
-      return calls.map((call) => call.name);
-    },
-  };
-};
-
-export const createFakeSpinner = (recorder = createCallRecorder()) => ({
-  succeed: (message?: string) => recorder.record("spinner.succeed", message),
-  fail: (message?: string) => recorder.record("spinner.fail", message),
-});
-
-export const createFakeExecutor = <Extra extends object = object>(
-  name: string,
-  extra: Extra = {} as Extra,
-  recorder = createCallRecorder(),
-) =>
-  ({
-    name,
-    cwdPath: `/workspace/${name}`,
-    workspaceRoot: "/workspace",
-    spinning: (message: string) => {
-      recorder.record(`${name}.spinning`, message);
-      return createFakeSpinner(recorder);
-    },
-    spawn: async (...args: unknown[]) => {
-      recorder.record(`${name}.spawn`, ...args);
-      return "";
-    },
-    exec: async (...args: unknown[]) => {
-      recorder.record(`${name}.exec`, ...args);
-      return "";
-    },
-    scan: async (...args: unknown[]) => {
-      recorder.record(`${name}.scan`, ...args);
-      return { name };
-    },
-    scanSync: async (...args: unknown[]) => {
-      recorder.record(`${name}.scanSync`, ...args);
-      return { name };
-    },
-    ...extra,
-  }) as Extra & {
-    name: string;
-    cwdPath: string;
-    workspaceRoot: string;
-    spinning: (message: string) => ReturnType<typeof createFakeSpinner>;
-    spawn: (...args: unknown[]) => Promise<string>;
-    exec: (...args: unknown[]) => Promise<string>;
-    scan: (...args: unknown[]) => Promise<{ name: string }>;
-    scanSync: (...args: unknown[]) => Promise<{ name: string }>;
-  };
-
-export const makeCliTempWorkspace = async () => {
-  const root = await mkdtemp(path.join(os.tmpdir(), "akan-cli-"));
-  await mkdir(root, { recursive: true });
-  await writeText(path.join(root, ".gitignore"), "");
-  const workspace = new WorkspaceExecutor({ workspaceRoot: root, repoName: "repo" });
-  return { root, workspace };
-};
-
-export const cleanupCliTempWorkspace = async (root: string) => {
-  await rm(root, { recursive: true, force: true });
-};
-
-export const writeText = async (filePath: string, content: string) => {
-  await mkdir(path.dirname(filePath), { recursive: true });
-  await writeFile(filePath, content);
-};
-
-export const writeJson = async (filePath: string, value: object) => {
-  await writeText(filePath, `${JSON.stringify(value, null, 2)}\n`);
-};
-
-export const createTempApp = async (appName = "demo") => {
-  const { root, workspace } = await makeCliTempWorkspace();
-  await writeJson(path.join(root, "package.json"), {
-    name: "repo",
-    version: "1.0.0",
-    description: "repo",
-    dependencies: {
-      react: "19.0.0",
-      "react-dom": "19.0.0",
-      "react-server-dom-webpack": "19.0.0",
-      sharp: "1.0.0",
-    },
-  });
-  await writeJson(path.join(root, "tsconfig.json"), {
-    compilerOptions: { target: "ESNext", paths: {} },
-    references: [],
-  });
-  await writeJson(path.join(root, "apps", appName, "tsconfig.json"), {
-    compilerOptions: { target: "ESNext", paths: {} },
-  });
-  await writeJson(path.join(root, "apps", appName, "package.json"), {
-    name: appName,
-    version: "1.0.0",
-    description: appName,
-    dependencies: {},
-    devDependencies: {},
-  });
-  await writeText(path.join(root, "apps", appName, "akan.config.ts"), "export default {};\n");
-  await mkdir(path.join(root, "apps", appName, "lib", "__scalar"), { recursive: true });
-  const app = AppExecutor.from(workspace, appName);
-  return { root, workspace, app };
-};
-
-export const createTempLib = async (libName = "shared") => {
-  const { root, workspace } = await makeCliTempWorkspace();
-  await writeJson(path.join(root, "package.json"), {
-    name: "repo",
-    version: "1.0.0",
-    description: "repo",
-    dependencies: {},
-    devDependencies: {},
-  });
-  await writeJson(path.join(root, "tsconfig.json"), {
-    compilerOptions: { target: "ESNext", paths: {} },
-    references: [],
-  });
-  const lib = LibExecutor.from(workspace, libName);
-  return { root, workspace, lib };
-};
-
-export const createTempPackage = async (pkgName = "@sample/tool") => {
-  const { root, workspace } = await makeCliTempWorkspace();
-  await writeJson(path.join(root, "package.json"), {
-    name: "repo",
-    version: "1.0.0",
-    description: "repo",
-    dependencies: { lodash: "4.0.0" },
-    devDependencies: { typescript: "6.0.0" },
-  });
-  await writeJson(path.join(root, "tsconfig.json"), {
-    compilerOptions: { target: "ESNext", paths: {} },
-  });
-  await writeJson(path.join(root, "pkgs", pkgName, "package.json"), {
-    name: pkgName,
-    version: "0.1.0",
-    description: "tool",
-    exports: {},
-  });
-  await writeJson(path.join(root, "pkgs", pkgName, "tsconfig.json"), {
-    compilerOptions: { target: "ESNext", paths: {} },
-  });
-  await writeText(path.join(root, "pkgs", pkgName, "index.ts"), 'import "lodash";\nexport const value = 1;\n');
-  const pkg = PkgExecutor.from(workspace, pkgName);
-  return { root, workspace, pkg };
-};
-
-export const createTempModule = async (moduleName = "post") => {
-  const { root, workspace, app } = await createTempApp("demo");
-  const module = ModuleExecutor.from(app, moduleName);
-  return { root, workspace, app, module };
-};

package/cli/workspace/workspace.command.ts

@@ -1,55 +0,0 @@
-import { command, Exec, Workspace } from "akanjs/devkit";
-
-import { WorkspaceScript } from "./workspace.script";
-
-export class WorkspaceCommand extends command("workspace", [WorkspaceScript], ({ public: target }) => ({
-  createWorkspace: target({ desc: "Create a new Akan.js workspace", runsOnWorkspaceRoot: false })
-    .arg("workspaceName", String, { desc: "what is the name of your organization?" })
-    .option("app", String, {
-      desc: "what is the codename of your first application? (e.g. myapp)",
-    })
-    .option("dir", String, {
-      desc: "directory of workspace",
-      default: process.env.USE_AKANJS_PKGS === "true" ? "local" : ".",
-    })
-    .option("libs", Boolean, {
-      desc: "Do you want to install shared and util libraries? (admin, user file, etc.)",
-      enum: [
-        { label: "No, I want to start with empty workspace (Recommended)", value: false },
-        {
-          label: "Yes, I want to accelerate development by installing shared and util libraries (for akanjs experts)",
-          value: true,
-        },
-      ],
-    })
-    .option("init", Boolean, {
-      desc: "Do you want to initialize the workspace? (Recommended)",
-      default: true,
-    })
-    .exec(async function (workspaceName, app, dir, libs, init) {
-      const appName = app || "app";
-      await this.workspaceScript.createWorkspace(
-        workspaceName.toLowerCase().replace(/ /g, "-"),
-        appName.toLowerCase().replace(/ /g, "-"),
-        { dirname: dir, installLibs: libs, init },
-      );
-    }),
-  lint: target({ desc: "Lint and fix code in a specific app/lib/pkg" })
-    .with(Exec)
-    .option("fix", Boolean, { default: true })
-    .with(Workspace)
-    .exec(async function (exec, fix, workspace) {
-      await this.workspaceScript.lint(exec, workspace, { fix });
-    }),
-  lintAll: target({ desc: "Lint and fix code in all apps and libraries" })
-    .option("fix", Boolean, { default: true })
-    .with(Workspace)
-    .exec(async function (fix, workspace) {
-      await this.workspaceScript.lintAll(workspace, { fix });
-    }),
-  syncAll: target({ desc: "Sync dependencies and configuration for all apps and libraries" })
-    .with(Workspace)
-    .exec(async function (workspace) {
-      await this.workspaceScript.syncAll(workspace);
-    }),
-})) {}

package/cli/workspace/workspace.runner.ts

@@ -1,79 +0,0 @@
-import path from "node:path";
-import { type Exec, FileSys, type PackageJson, runner, type Workspace, WorkspaceExecutor } from "akanjs/devkit";
-import { getLatestPackageVersion } from "../npmRegistry";
-
-export class WorkspaceRunner extends runner("workspace") {
-  async createWorkspace(
-    repoName: string,
-    appName: string,
-    { dirname = ".", init = true, akanVersion }: { dirname?: string; init?: boolean; akanVersion: string },
-  ) {
-    const cwdPath = process.cwd();
-    const workspaceRoot = path.join(cwdPath, dirname, repoName);
-
-    const workspace = WorkspaceExecutor.fromRoot({ workspaceRoot, repoName });
-    const templateSpinner = workspace.spinning(`Creating workspace template files in ${dirname}/${repoName}...`);
-    const latestTypesBunVersion = await getLatestPackageVersion("@types/bun");
-    await workspace.applyTemplate({
-      basePath: ".",
-      template: "workspaceRoot",
-      dict: { repoName, appName, serveDomain: "localhost" },
-    });
-    templateSpinner.succeed(`Workspace files created in ${dirname}/${repoName}`);
-    
-    const [rootPackageJson, peerDependencies] = await Promise.all([
-      workspace.getPackageJson(),
-      this.#getAkanPeerDependencies(),
-    ]);
-    const packageJson: PackageJson = {
-      ...rootPackageJson,
-      dependencies: {
-        ...rootPackageJson.dependencies,
-        ...peerDependencies,
-        akanjs: akanVersion,
-      },
-      devDependencies: {
-        ...rootPackageJson.devDependencies,
-        "@types/bun": latestTypesBunVersion,
-      },
-    };
-    await workspace.setPackageJson(packageJson);
-
-    if (init) {
-      const installSpinner = workspace.spinning("Installing dependencies with bun...");
-      await workspace.spawn("bun", ["install"]);
-      installSpinner.succeed("Dependencies installed with bun");
-    }
-
-    return workspace;
-  }
-
-  async #getAkanPeerDependencies(): Promise<Record<string, string>> {
-    const packageJson = await this.#getAkanPackageJson();
-    return packageJson.peerDependencies ?? {};
-  }
-
-  async #getAkanPackageJson(): Promise<PackageJson> {
-    let current = import.meta.dir;
-    for (let depth = 0; depth < 6; depth++) {
-      const packageJsonPath = path.join(current, "package.json");
-      if (await Bun.file(packageJsonPath).exists()) {
-        const packageJson = await FileSys.readJson<PackageJson>(packageJsonPath);
-        if (packageJson.name === "akanjs") return packageJson;
-      }
-      const parent = path.dirname(current);
-      if (parent === current) break;
-      current = parent;
-    }
-    throw new Error(`[workspace] failed to locate akanjs package.json from ${import.meta.dir}`);
-  }
-
-  async lint(exec: Exec, workspace: Workspace, { fix = true }: { fix?: boolean } = {}) {
-    await workspace.spawn("./node_modules/.bin/biome", [
-      "check",
-      ...(fix ? ["--write"] : []),
-      "--no-errors-on-unmatched",
-      exec.cwdPath,
-    ]);
-  }
-}

package/cli/workspace/workspace.script.ts

@@ -1,74 +0,0 @@
-import path from "node:path";
-import { Logger } from "akanjs/common";
-import { AppExecutor, type Exec, LibExecutor, PkgExecutor, script, type Workspace } from "akanjs/devkit";
-
-import { ApplicationScript } from "../application/application.script";
-import { LibraryScript } from "../library/library.script";
-import { PackageScript } from "../package/package.script";
-import { WorkspaceRunner } from "./workspace.runner";
-
-export class WorkspaceScript extends script("workspace", [
-  WorkspaceRunner,
-  ApplicationScript,
-  LibraryScript,
-  PackageScript,
-]) {
-  async createWorkspace(
-    repoName: string,
-    appName: string,
-    { dirname = ".", installLibs = false, init = true }: { dirname?: string; installLibs?: boolean; init?: boolean },
-  ) {
-    const akanVersion = await this.packageScript.version(null, { log: false });
-    const workspace = await this.workspaceRunner.createWorkspace(repoName, appName, {
-      dirname,
-      init,
-      akanVersion,
-    });
-    if (installLibs) {
-      await this.libraryScript.installLibrary(workspace, "util");
-      await this.libraryScript.installLibrary(workspace, "shared");
-    }
-    await this.applicationScript.createApplication(appName, workspace, { libs: installLibs ? ["util", "shared"] : [] });
-    const gitSpinner = workspace.spinning("Initializing git repository and commit...");
-    try {
-      await workspace.commit("Initial commit", { init: true });
-      gitSpinner.succeed("Git repository initialized and committed");
-    } catch (_) {
-      gitSpinner.fail("Git repository initialization failed. It's not fatal, you can commit manually");
-    }
-    const workspacePath = path.join(dirname, repoName);
-    Logger.rawLog(`\n🎉 Welcome aboard! Workspace created in ${dirname}/${repoName}`);
-    Logger.rawLog(`🚀 Run \`cd ${workspacePath} && akan start ${appName}\` to start the development server.`);
-    
-    Logger.rawLog(`\n👋 Happy coding!`);
-  }
-  async lint(exec: Exec, workspace: Workspace, { fix = true }: { fix?: boolean } = {}) {
-    if (exec instanceof AppExecutor) await this.applicationScript.sync(exec);
-    else if (exec instanceof LibExecutor) await this.libraryScript.syncLibrary(exec);
-    const spinner = workspace.spinning(`Linting${fix ? " with fix" : ""}...`);
-    try {
-      await this.workspaceRunner.lint(exec, workspace, { fix });
-      spinner.succeed("Lint completed with no errors");
-    } catch (error) {
-      spinner.fail("Lint failed with errors");
-      throw error;
-    }
-  }
-  async lintAll(workspace: Workspace, { fix = true }: { fix?: boolean } = {}) {
-    const [appNames, libNames, pkgNames] = await workspace.getExecs();
-    await Promise.all(appNames.map((appName) => this.applicationScript.sync(AppExecutor.from(workspace, appName))));
-    await Promise.all(libNames.map((libName) => this.libraryScript.syncLibrary(LibExecutor.from(workspace, libName))));
-    await Promise.all([
-      ...appNames.map((appName) => this.workspaceRunner.lint(AppExecutor.from(workspace, appName), workspace, { fix })),
-      ...libNames.map((libName) => this.workspaceRunner.lint(LibExecutor.from(workspace, libName), workspace, { fix })),
-      ...pkgNames
-        .filter((pkgName) => pkgName !== "contract") 
-        .map((pkgName) => this.workspaceRunner.lint(PkgExecutor.from(workspace, pkgName), workspace, { fix })),
-    ]);
-  }
-  async syncAll(workspace: Workspace) {
-    const [appNames, libNames] = await workspace.getExecs();
-    for (const libName of libNames) await this.libraryScript.syncLibrary(LibExecutor.from(workspace, libName));
-    for (const appName of appNames) await this.applicationScript.sync(AppExecutor.from(workspace, appName));
-  }
-}

package/devkit/aiEditor.ts

@@ -1,299 +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 { getAkanGlobalConfig, setAkanGlobalConfig } from "./auth";
-import type { Executor, WorkspaceExecutor } from "./executors";
-import { Spinner } from "./spinner";
-import type { FileContent } from "./types";
-
-const MAX_ASK_TRY = 300;
-
-export const supportedLlmModels = ["deepseek-chat", "deepseek-reasoner"] as const;
-export type SupportedLlmModel = (typeof supportedLlmModels)[number];
-
-interface EditOptions {
-  onReasoning?: (reasoning: string) => void;
-  onChunk?: (chunk: string) => void;
-  maxTry?: number;
-  validate?: string[];
-  approve?: boolean;
-}
-
-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 = new ChatDeepSeek({
-      modelName: model,
-      temperature,
-      streaming: true,
-      apiKey,
-    });
-    return AiSession;
-  }
-  static async getLlmConfig() {
-    const akanConfig = await getAkanGlobalConfig();
-    return akanConfig.llm ?? null;
-  }
-  static async setLlmConfig(llmConfig: { model: SupportedLlmModel; apiKey: string } | null) {
-    const akanConfig = await getAkanGlobalConfig();
-    akanConfig.llm = llmConfig;
-    await setAkanGlobalConfig(akanConfig);
-    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 = new ChatOpenAI({
-      modelName,
-      temperature: 0,
-      configuration: { baseURL: "https://api.deepseek.com/v1", 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 = "",
-        tokenIdx = 0;
-      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); 
-        }
-        tokenIdx++;
-      }
-      fullResponse += "\n";
-      onChunk("\n");
-      this.messageHistory.push(new AIMessage(fullResponse));
-      return { content: fullResponse, messageHistory: this.messageHistory };
-    } catch (error) {
-      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 }: 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")}`;
-        response = await this.ask(validateQuestion, { onChunk, onReasoning });
-      }
-      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) {
-    
-    const code = /```(typescript|tsx)([\s\S]*?)```/.exec(content);
-
-    return code?.[2] ?? content;
-  }
-  addToolMessgaes(messages: { type: string; content: string }[]) {
-
-    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);
-    const writes = this.#getTypescriptCodes(content);
-    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 = {}) {
-    const content = await this.edit(question, options);
-    return this.#getTypescriptCodes(content);
-  }
-  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 typeCheckResult = executor.typeCheck(filePath);
-          const lintResult = await executor.lint(filePath);
-          const needFix = !!typeCheckResult.fileErrors.length || !!lintResult.errors.length;
-          return { filePath, typeCheckResult, lintResult, needFix };
-        }),
-      );
-      const needFix = fileChecks.some((fileCheck) => fileCheck.needFix);
-      if (needFix) {
-        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,
-        });
-        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[] {
-    const codes = text.match(/```(typescript|tsx)([\s\S]*?)```/g);
-    if (!codes) return [];
-    const result = codes.map((code) => {
-      const content = /```(typescript|tsx)([\s\S]*?)```/.exec(code)?.[2];
-      if (!content) return null;
-      const filePath = /\/\/ File: (.*?)(?:\n|$)/.exec(content)?.[1]?.trim();
-      if (!filePath) return null;
-      const contentWithoutFilepath = content.replace(`// File: ${filePath}\n`, "").trim();
-      return { filePath, content: contentWithoutFilepath };
-    });
-    return result.filter((code) => code !== null) as FileContent[];
-  }
-  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();
-  }
-}