@akanjs/devkit 3.0.0-beta.9 → 3.0.0

package/workspaceLayout.ts

@@ -1,21 +1,13 @@
-/**
- * App/lib 루트 레이아웃 허용 목록 — 단일 소스.
- *
- * 같은 규칙을 scanInfo(`akan sync`, hard error) · akanContext(`akan doctor`, diagnostic) ·
- * qualityScanner(`akan quality scan`, warning) 세 곳이 각자 복사해 두면서 실제로 어긋났다
- * (스코프 AGENTS.md/CLAUDE.md 는 sync 만 허용, `plugin` 은 문서에만, `secrets` 는 doctor 만 거부).
- * 규칙을 추가할 때는 이 파일만 고치고, 루트 AGENTS.md 의 목록도 같이 갱신한다.
- */
+// The one source of the app/lib root allowlists (sync, doctor and quality scan read it); mirror a change into the
+// root AGENTS.md list.
 
 export type SysType = "app" | "lib";
 
 export const appRootAllowedFiles = new Set([
-  // 스코프 에이전트 가이드 — scan(write) 이 유지하는 색인 + 마커 밖 hand-written 내용 (agentsIndex.ts)
   "AGENTS.md",
   "CLAUDE.md",
   "akan.app.json",
   "akan.config.ts",
-  "capacitor.config.ts",
   "client.ts",
   "main.ts",
   "package.json",
@@ -26,12 +18,10 @@ export const appRootAllowedFiles = new Set([
 
 export const appRootAllowedDirs = new Set([
   ".akan",
-  "android",
   "common",
   "env",
-  "ios",
   "lib",
-  "mobile",
+  "native",
   "page",
   "plugin",
   "private",
@@ -43,12 +33,7 @@ export const appRootAllowedDirs = new Set([
   "webkit",
 ]);
 
-/**
- * 라이브러리 루트는 앱 루트에서 실행/모바일 전용 항목(`main.ts`, `capacitor.config.ts`, `.akan`,
- * `android`, `ios`, `mobile`, `script`, `secrets`)을 뺀 집합이다 — 라이브러리는 부팅되지도, 패키징되지도
- * 않는다. `index.ts` 는 lib 에만 생성되고, `README.md` / `tsconfig.spec.json` 은 라이브러리가 패키지로
- * 배포되기 때문에 남는다. `public` / `private` 은 syncAssets 가 앱으로 심링크하므로 라이브러리도 가진다.
- */
+// A library is never booted or packaged as an app, so the run/mobile entries are out; it is published, so README stays.
 export const libRootAllowedFiles = new Set([
   "AGENTS.md",
   "CLAUDE.md",
@@ -68,6 +53,7 @@ export const libRootAllowedDirs = new Set([
   "common",
   "env",
   "lib",
+  "native",
   "page",
   "plugin",
   "private",
@@ -98,9 +84,22 @@ const libFacetRootTestPattern = /^[A-Za-z][A-Za-z0-9_-]*\.signal\.(test|spec)\.(
 export const isAllowedLibFacetRootFile = (filename: string) =>
   libFacetRootAllowedFiles.has(filename) || libFacetRootTestPattern.test(filename);
 
-/**
- * scanSync 는 루트를 `Bun.Glob("*")` 로 읽어 dotfile 을 아예 보지 못한다. 디렉터리를 직접 읽는
- * doctor 가 그 차이만큼 `.DS_Store` 같은 툴 산출물을 에러로 올리므로 같은 기준으로 걸러낸다.
- */
+//* What a Capacitor app kept in its root. The native runtime generates its projects under `.akan/native/<target>`, so
+//* these are named as leftovers instead of as unknown entries.
+const retiredAppRootEntries = new Set([
+  "android",
+  "ios",
+  "mobile",
+  "capacitor.config.ts",
+  "capacitor.config.js",
+  "capacitor.config.json",
+]);
+
+export const rootEntryHintOf = (type: SysType, name: string) =>
+  type === "app" && retiredAppRootEntries.has(name)
+    ? "a Capacitor-era entry; the native runtime generates its projects under .akan/native/<target>, so delete it"
+    : null;
+
+// scanSync reads roots through `Bun.Glob("*")`, which skips dotfiles, so doctor skips them the same way.
 export const isScannedRootEntry = (type: SysType, name: string) =>
   !name.startsWith(".") || rootAllowedDirs[type].has(name);

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();
-  }
-}