@akanjs/devkit 1.0.20 → 2.1.0-rc.1

package/lint/no-js-private-class-method.grit

@@ -0,0 +1,42 @@
+engine biome(1.0)
+language js(typescript, jsx)
+
+or {
+  JsMethodClassMember() as $method where {
+    $method <: contains JsPrivateClassMemberName() as $name,
+    $method <: r"async\s+#",
+    $method <: contains `async` as $asyncToken,
+    $name <: r"#(.*)"($bareName),
+    $privateName = join(list = ["_", $bareName], separator = ""),
+    register_diagnostic(
+      span = $method,
+      message = "JavaScript private class methods (#) should not be used in mixin-enabled modules. Use a TypeScript private method with an underscore prefix instead.",
+      severity = "error"
+    ),
+    $asyncToken => `private async`,
+    $name => $privateName
+  },
+  JsMethodClassMember() as $method where {
+    $method <: contains JsPrivateClassMemberName() as $name,
+    not $method <: r"async\s+#",
+    $name <: r"#(.*)"($bareName),
+    $privateName = join(list = ["private _", $bareName], separator = ""),
+    register_diagnostic(
+      span = $method,
+      message = "JavaScript private class methods (#) should not be used in mixin-enabled modules. Use a TypeScript private method with an underscore prefix instead.",
+      severity = "error"
+    ),
+    $name => $privateName
+  },
+  JsCallExpression() as $call where {
+    $call <: contains JsPrivateName() as $name,
+    $name <: r"#(.*)"($bareName),
+    $privateName = join(list = ["_", $bareName], separator = ""),
+    register_diagnostic(
+      span = $call,
+      message = "Calls to JavaScript private class methods (#) should use the underscore-prefixed TypeScript private method.",
+      severity = "error"
+    ),
+    $name => $privateName
+  }
+}

package/lint/no-use-client-in-server.grit

@@ -0,0 +1,7 @@
+`$directive` where {
+  $directive <: `"use client"`,
+  register_diagnostic(
+    span = $directive,
+    message = "`use client` should not be used at the top of a server file."
+  )
+}

package/lint/non-scalar-props-restricted.grit

@@ -0,0 +1,13 @@
+`$name={$value}` where {
+  or {
+    $value <: `($$$_) => $_`,
+    $value <: `$_ => $_`,
+    $value <: `function($$$_) { $$$_ }`,
+    $value <: `function $fnName($$$_) { $$$_ }`
+  },
+  not $name <: or { `loader`, `render`, `of` },
+  register_diagnostic(
+    span = $name,
+    message = "Non-scalar props (function expressions) should not be used in server components. Allowed: loader, render, of."
+  )
+}

package/linter.ts

@@ -0,0 +1,271 @@
+import { existsSync, readFileSync } from "node:fs";
+import * as path from "node:path";
+import { Logger } from "akanjs/common";
+import chalk from "chalk";
+// import { ESLint, type Linter as ESLintLinter } from "eslint";
+
+export class Linter {
+  #logger = new Logger("Linter");
+  // #eslint: any;
+  lintRoot: string;
+
+  constructor(cwdPath: string) {
+    this.lintRoot = this.#findEslintRootPath(cwdPath);
+    // this.#eslint = new ESLint({ cwd: this.lintRoot, errorOnUnmatchedPattern: false });
+  }
+  #findEslintRootPath(dir: string): string {
+    const configPath = path.join(dir, "eslint.config.ts");
+    if (existsSync(configPath)) return dir;
+    const parentDir = path.dirname(dir);
+    return this.#findEslintRootPath(parentDir);
+  }
+  async lint(filePath: string, { fix = false, dryRun = false }: { fix?: boolean; dryRun?: boolean } = {}) {
+    if (fix) return await this.fixFile(filePath, dryRun);
+    return await this.lintFile(filePath);
+  }
+
+  /**
+   * Lint a single file using ESLint
+   * @param filePath - Path to the file to lint
+   * @returns Array of ESLint results
+   */
+  async lintFile(filePath: string): Promise<{
+    fixed: boolean;
+    output?: string;
+    results: any[]; // ESLint.LintResult[];
+    errors: any[]; // ESLintLinter.LintMessage[];
+    warnings: any[]; // ESLintLinter.LintMessage[];
+  }> {
+    if (!existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
+    // const isIgnored = await this.#eslint.isPathIgnored(filePath);
+    // if (isIgnored) {
+    //   this.#logger.warn(`File ${filePath} is ignored by ESLint configuration`);
+    //   return { fixed: false, results: [], errors: [], warnings: [] };
+    // }
+    // const results = await this.#eslint.lintFiles([filePath]);
+    // const errors = results.flatMap((result) => result.messages.filter((message) => message.severity === 2));
+    // const warnings = results.flatMap((result) => result.messages.filter((message) => message.severity === 1));
+    return { fixed: false, results: [], errors: [], warnings: [] };
+  }
+
+  /**
+   * Format lint results for console output
+   * @param results - Array of ESLint results
+   * @returns Formatted string
+   */
+  formatLintResults(results: any[]): string {
+    // ESLint.LintResult[]
+    if (results.length === 0) return "No files to lint";
+
+    const output: string[] = [];
+    let totalErrors = 0;
+    let totalWarnings = 0;
+
+    results.forEach((result) => {
+      totalErrors += result.errorCount;
+      totalWarnings += result.warningCount;
+
+      if (result.messages.length > 0) {
+        output.push(`\n${chalk.cyan(result.filePath)}`);
+
+        // Read source file once
+        let sourceLines: string[] = [];
+        if (existsSync(result.filePath)) {
+          try {
+            const sourceContent = readFileSync(result.filePath, "utf8");
+            sourceLines = sourceContent.split("\n");
+          } catch (error) {
+            // Ignore read errors
+          }
+        }
+
+        result.messages.forEach((message: any) => {
+          const type = message.severity === 2 ? "error" : "warning";
+          const typeColor = message.severity === 2 ? chalk.red : chalk.yellow;
+          const icon = message.severity === 2 ? "❌" : "⚠️";
+          const ruleInfo = message.ruleId ? chalk.dim(` (${message.ruleId})`) : "";
+
+          output.push(`\n  ${icon} ${typeColor(type)}: ${message.message}${ruleInfo}`);
+          output.push(`     ${chalk.gray("at")} ${result.filePath}:${chalk.bold(`${message.line}:${message.column}`)}`);
+
+          // Show source line with underline
+          if (sourceLines.length > 0 && message.line <= sourceLines.length) {
+            const sourceLine = sourceLines[message.line - 1];
+            const lineNumber = message.line.toString().padStart(5, " ");
+
+            output.push(`\n${chalk.dim(`${lineNumber} |`)} ${sourceLine}`);
+
+            // Create underline
+            const underlinePrefix = " ".repeat(message.column - 1);
+            const underlineLength = message.endColumn ? message.endColumn - message.column : 1;
+            const underline = "^".repeat(Math.max(1, underlineLength));
+
+            output.push(`${chalk.dim(`${" ".repeat(lineNumber.length)} |`)} ${underlinePrefix}${typeColor(underline)}`);
+          }
+        });
+      }
+    });
+
+    if (totalErrors === 0 && totalWarnings === 0) return chalk.bold("✅ No ESLint errors or warnings found");
+
+    const errorText = totalErrors > 0 ? chalk.red(`${totalErrors} error(s)`) : "0 errors";
+    const warningText = totalWarnings > 0 ? chalk.yellow(`${totalWarnings} warning(s)`) : "0 warnings";
+    const summary = [`\n${errorText}, ${warningText} found`];
+
+    return summary.concat(output).join("\n");
+  }
+
+  /**
+   * Get detailed lint information
+   * @param filePath - Path to the file to lint
+   * @returns Object containing detailed lint information
+   */
+  async getDetailedLintInfo(filePath: string): Promise<{
+    results: any[]; // ESLint.LintResult[];
+    details: {
+      line: number;
+      column: number;
+      message: string;
+      ruleId: string | null;
+      severity: "error" | "warning";
+      fix?: {
+        range: [number, number];
+        text: string;
+      };
+      suggestions?: {
+        desc: string;
+        fix: {
+          range: [number, number];
+          text: string;
+        };
+      }[];
+    }[];
+    stats: {
+      errorCount: number;
+      warningCount: number;
+      fixableErrorCount: number;
+      fixableWarningCount: number;
+    };
+  }> {
+    const { results } = await this.lintFile(filePath);
+
+    const details = results.flatMap((result) =>
+      result.messages.map((message: any) => ({
+        line: message.line,
+        column: message.column,
+        message: message.message,
+        ruleId: message.ruleId,
+        severity: message.severity === 2 ? ("error" as const) : ("warning" as const),
+        fix: message.fix,
+        suggestions: message.suggestions,
+      })),
+    );
+
+    const stats = results.reduce(
+      (acc, result) => ({
+        errorCount: acc.errorCount + result.errorCount,
+        warningCount: acc.warningCount + result.warningCount,
+        fixableErrorCount: acc.fixableErrorCount + result.fixableErrorCount,
+        fixableWarningCount: acc.fixableWarningCount + result.fixableWarningCount,
+      }),
+      { errorCount: 0, warningCount: 0, fixableErrorCount: 0, fixableWarningCount: 0 },
+    );
+
+    return { results, details, stats };
+  }
+
+  /**
+   * Check if a file has lint errors
+   * @param filePath - Path to the file to check
+   * @returns true if there are no errors, false otherwise
+   */
+  async hasNoLintErrors(filePath: string): Promise<boolean> {
+    try {
+      const { results } = await this.lintFile(filePath);
+      return results.every((result) => result.errorCount === 0);
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get only error messages (excluding warnings)
+   * @param filePath - Path to the file to lint
+   * @returns Array of error messages
+   */
+  async getErrors(filePath: string): Promise<any[]> {
+    // ESLintLinter.LintMessage[]
+    const { results } = await this.lintFile(filePath);
+    return results.flatMap((result) => result.messages.filter((message: any) => message.severity === 2));
+  }
+
+  /**
+   * Get only warning messages
+   * @param filePath - Path to the file to lint
+   * @returns Array of warning messages
+   */
+  async getWarnings(filePath: string): Promise<any[]> {
+    // ESLintLinter.LintMessage[]
+    const { results } = await this.lintFile(filePath);
+    return results.flatMap((result) => result.messages.filter((message: any) => message.severity === 1));
+  }
+
+  /**
+   * Fix lint errors automatically
+   * @param filePath - Path to the file to fix
+   * @param dryRun - If true, returns the fixed content without writing to file
+   * @returns Fixed content and remaining issues
+   */
+  async fixFile(
+    filePath: string,
+    dryRun = false,
+  ): Promise<{
+    fixed: boolean;
+    output?: string;
+    results: any[]; // ESLint.LintResult[];
+    errors: any[]; // ESLintLinter.LintMessage[];
+    warnings: any[]; // ESLintLinter.LintMessage[];
+  }> {
+    if (!existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
+
+    // const eslint = new ESLint({ cwd: this.lintRoot, fix: true });
+    // const results = await eslint.lintFiles([filePath]);
+    // const errors = results.flatMap((result) => result.messages.filter((message) => message.severity === 2));
+    // const warnings = results.flatMap((result) => result.messages.filter((message) => message.severity === 1));
+    // if (!dryRun) await ESLint.outputFixes(results);
+
+    // const fixedResult = results[0];
+    // return { fixed: fixedResult.output !== undefined, output: fixedResult.output, results, errors, warnings };
+    return { fixed: false, output: undefined, results: [], errors: [], warnings: [] };
+  }
+
+  /**
+   * Get ESLint configuration for a file
+   * @param filePath - Path to the file
+   * @returns ESLint configuration object
+   */
+  async getConfigForFile(filePath: string): Promise<unknown> {
+    // const eslint = new ESLint();
+    // const config = (await eslint.calculateConfigForFile(filePath)) as unknown;
+    // return config;
+    return {};
+  }
+
+  /**
+   * Get rules that are causing errors in a file
+   * @param filePath - Path to the file to check
+   * @returns Object mapping rule IDs to their error counts
+   */
+  async getProblematicRules(filePath: string): Promise<Record<string, number>> {
+    const { results } = await this.lintFile(filePath);
+    const ruleCounts: Record<string, number> = {};
+
+    results.forEach((result) => {
+      result.messages.forEach((message: any) => {
+        if (message.ruleId) ruleCounts[message.ruleId] = (ruleCounts[message.ruleId] || 0) + 1;
+      });
+    });
+
+    return ruleCounts;
+  }
+}

package/mobile/index.ts

@@ -0,0 +1 @@
+export * from "./mobileTarget";

package/mobile/mobileTarget.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, test } from "bun:test";
+import type { AkanMobileTargetConfig } from "../akanConfig";
+import type { App } from "../commandDecorators";
+import { getMobileTargetChoices, resolveMobilePath, resolveMobileTargets, targetHtmlFilename } from "./mobileTarget";
+
+const target = {
+  name: "akanjs",
+  basePath: "akanjs",
+  appName: "Akanjs",
+  appId: "com.akanjs.app",
+  version: "1.0.0",
+  buildNum: 1,
+} as AkanMobileTargetConfig;
+
+describe("mobile target helpers", () => {
+  test("maps deep links into target base paths without duplicating prefixes", () => {
+    expect(resolveMobilePath(target, "/order/123")).toBe("/akanjs/order/123");
+    expect(resolveMobilePath(target, "/akanjs/order/123")).toBe("/akanjs/order/123");
+    expect(resolveMobilePath({ ...target, basePath: undefined }, "/order/123")).toBe("/order/123");
+  });
+
+  test("selects the self-contained html file for a target", () => {
+    expect(targetHtmlFilename(target)).toBe("akanjs.html");
+    expect(targetHtmlFilename({ ...target, basePath: undefined })).toBe("index.html");
+  });
+
+  test("lists route base paths when only one mobile target is configured", async () => {
+    const app = {
+      getConfig: async () => ({
+        basePaths: new Set(["akanjs", "soft", "office"]),
+        mobile: { targets: { akanjs: target } },
+      }),
+    } as unknown as App;
+
+    await expect(getMobileTargetChoices(app)).resolves.toEqual(["akanjs", "soft", "office"]);
+  });
+
+  test("resolves a route base path onto the default mobile target config", async () => {
+    const app = {
+      getConfig: async () => ({
+        basePaths: new Set(["akanjs", "soft", "office"]),
+        mobile: { targets: { akanjs: target } },
+      }),
+    } as unknown as App;
+
+    await expect(resolveMobileTargets(app, "soft")).resolves.toEqual([
+      {
+        name: "soft",
+        config: { ...target, name: "soft", basePath: "soft" },
+      },
+    ]);
+  });
+});

package/mobile/mobileTarget.ts

@@ -0,0 +1,88 @@
+import type { AkanMobileTargetConfig, MobileEnv } from "../akanConfig";
+import type { App } from "../commandDecorators";
+
+export type MobilePlatform = "ios" | "android";
+export type MobileTargetSelection = string | "all" | undefined;
+
+export interface ResolvedMobileTarget {
+  name: string;
+  config: AkanMobileTargetConfig;
+}
+
+export const MOBILE_ENVS = ["local", "debug", "develop", "main"] as const satisfies readonly MobileEnv[];
+
+export const getMobileTargets = async (app: App): Promise<ResolvedMobileTarget[]> => {
+  const config = await app.getConfig();
+  return Object.entries(config.mobile.targets).map(([name, target]) => ({ name, config: target }));
+};
+
+export const getMobileTargetChoices = async (app: App): Promise<string[]> => {
+  const config = await app.getConfig();
+  const targetNames = Object.keys(config.mobile.targets);
+  if (targetNames.length > 1) return targetNames;
+  const basePaths = [...config.basePaths];
+  if (basePaths.length > 1) return basePaths;
+  if (targetNames.length > 0) return targetNames;
+  return basePaths;
+};
+
+const resolveMobileTargetByBasePath = (
+  targets: ResolvedMobileTarget[],
+  basePath: string,
+): ResolvedMobileTarget | undefined => {
+  const normalizedBasePath = basePath.replace(/^\/+|\/+$/g, "");
+  const byBasePath = targets.find((target) => target.config.basePath?.replace(/^\/+|\/+$/g, "") === normalizedBasePath);
+  if (byBasePath) return byBasePath;
+  const [template] = targets;
+  if (!template) return undefined;
+  return {
+    name: normalizedBasePath,
+    config: {
+      ...template.config,
+      name: normalizedBasePath,
+      basePath: normalizedBasePath,
+    },
+  };
+};
+
+export const resolveMobileTargets = async (
+  app: App,
+  selection: MobileTargetSelection,
+): Promise<ResolvedMobileTarget[]> => {
+  const config = await app.getConfig();
+  const targets = await getMobileTargets(app);
+  if (targets.length === 0) throw new Error(`No mobile targets configured for ${app.name}`);
+  if (!selection) {
+    const choices = await getMobileTargetChoices(app);
+    if (choices.length === 1) return resolveMobileTargets(app, choices[0]);
+    throw new Error(`Multiple mobile targets found for ${app.name}. Pass --target <${choices.join("|")}|all>.`);
+  }
+  if (selection === "all") {
+    if (Object.keys(config.mobile.targets).length > 1) return targets;
+    const basePaths = [...config.basePaths];
+    if (basePaths.length > 1) {
+      return basePaths.flatMap((basePath) => {
+        const resolved = resolveMobileTargetByBasePath(targets, basePath);
+        return resolved ? [resolved] : [];
+      });
+    }
+    return targets;
+  }
+  const target = targets.find((candidate) => candidate.name === selection);
+  if (target) return [target];
+  const basePathTarget = resolveMobileTargetByBasePath(targets, selection);
+  if (basePathTarget && config.basePaths.has(selection.replace(/^\/+|\/+$/g, ""))) return [basePathTarget];
+  const choices = await getMobileTargetChoices(app);
+  throw new Error(`Mobile target '${selection}' was not found. Available: ${choices.join(", ")}`);
+};
+
+export const resolveMobilePath = (target: AkanMobileTargetConfig, pathname: string) => {
+  const basePath = target.basePath?.replace(/^\/+|\/+$/g, "");
+  const normalizedPath = `/${pathname.replace(/^\/+/, "")}`;
+  if (!basePath) return normalizedPath;
+  if (normalizedPath === `/${basePath}` || normalizedPath.startsWith(`/${basePath}/`)) return normalizedPath;
+  return `/${basePath}${normalizedPath === "/" ? "" : normalizedPath}`;
+};
+
+export const targetHtmlFilename = (target: AkanMobileTargetConfig) =>
+  target.basePath?.replace(/^\/+|\/+$/g, "") ? `${target.basePath.replace(/^\/+|\/+$/g, "")}.html` : "index.html";

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@akanjs/devkit",
-  "version": "1.0.20",
+  "version": "2.1.0-rc.1",
   "sourceType": "module",
+  "type": "module",
   "publishConfig": {
     "access": "public"
   },
@@ -12,41 +13,57 @@
     "url": "https://github.com/akan-team/akanjs.git",
     "directory": "pkgs/@akanjs/devkit"
   },
-  "main": "./index.js",
   "engines": {
-    "node": ">=20"
+    "bun": ">=1.3.13"
+  },
+  "exports": {
+    ".": {
+      "import": "./index.ts",
+      "types": "./index.ts",
+      "default": "./index.ts"
+    },
+    "./package.json": "./package.json",
+    "./capacitor.base.config": {
+      "import": "./capacitor.base.config.ts",
+      "types": "./capacitor.base.config.ts",
+      "default": "./capacitor.base.config.ts"
+    },
+    "./*": "./*"
   },
   "dependencies": {
-    "@inquirer/prompts": "^7.2.1",
-    "@langchain/core": "^0.3.56",
-    "@langchain/deepseek": "^0.0.1",
-    "@langchain/openai": "^0.5.10",
-    "@trapezedev/project": "^7.1.3",
-    "axios": "^1.7.9",
-    "chalk": "^5.4.1",
-    "commander": "^14.0.2",
-    "dotenv": "^16.4.7",
-    "esbuild": "^0.19.2",
-    "esbuild-plugin-d.ts": "^1.3.1",
-    "eslint": "^9.0.0",
-    "form-data": "^4.0.1",
+    "@inquirer/prompts": "^8.4.3",
+    "@langchain/core": "^1.1.47",
+    "@langchain/deepseek": "^1.0.26",
+    "@langchain/openai": "^1.4.6",
+    "@trapezedev/project": "^7.1.4",
+    "akanjs": "2.1.0-rc.0",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "fontaine": "^0.8.0",
+    "fonteditor-core": "^2.6.3",
     "ignore": "^7.0.5",
-    "ink": "^6.1.0",
-    "js-yaml": "^4.1.0",
-    "ora": "^3.4.0",
-    "react": "19.2.3",
-    "reflect-metadata": "^0.2.2",
-    "tunnel-ssh": "^5.2.0",
-    "typescript": "5.8.3"
+    "ink": "^6.8.0",
+    "js-yaml": "^4.1.1",
+    "ora": "^9.4.0",
+    "ssh2": "^1.17.0",
+    "subset-font": "^2.5.0",
+    "tailwindcss": "^4.3.0",
+    "typescript": "^6.0.3"
   },
-  "exports": {
-    ".": {
-      "require": "./cjs/index.js",
-      "import": "./esm/index.js",
-      "types": "./index.d.ts"
+  "peerDependencies": {
+    "@capacitor/cli": "^8.3.4",
+    "react": "19.2.6"
+  },
+  "peerDependenciesMeta": {
+    "@capacitor/cli": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
     }
   },
-  "esbuild": {
-    "platform": "node"
+  "devDependencies": {},
+  "bun": {
+    "platform": "bun"
   }
-}
+}

package/prompter.ts

@@ -0,0 +1,72 @@
+import fsPromise from "node:fs/promises";
+import { input, select } from "@inquirer/prompts";
+
+import { getDirname } from "./getDirname";
+import type { GuideGenerateJson } from "./guideline";
+
+interface FileUpdateRequestProps {
+  context: string;
+  request: string;
+}
+export class Prompter {
+  static async #getGuidelineRoot() {
+    const dirname = getDirname(import.meta.url);
+    const candidates = [`${dirname}/guidelines`, `${dirname}/../cli/guidelines`];
+    for (const candidate of candidates) {
+      try {
+        await fsPromise.access(candidate);
+        return candidate;
+      } catch {
+        // Try the next layout; source and bundled CLI resolve from different dirs.
+      }
+    }
+    return candidates[0];
+  }
+
+  static async selectGuideline() {
+    const guidelineRoot = await Prompter.#getGuidelineRoot();
+    const guideNames = (await fsPromise.readdir(guidelineRoot)).filter((name) => !name.startsWith("_"));
+    return await select({ message: "Select a guideline", choices: guideNames.map((name) => ({ name, value: name })) });
+  }
+  static async getGuideJson(guideName: string): Promise<GuideGenerateJson> {
+    const guidelineRoot = await Prompter.#getGuidelineRoot();
+    const filePath = `${guidelineRoot}/${guideName}/${guideName}.generate.json`;
+    const guideJson = await fsPromise.readFile(filePath, "utf-8");
+    return JSON.parse(guideJson) as GuideGenerateJson;
+  }
+  static async getInstruction(guideName: string): Promise<string> {
+    const guidelineRoot = await Prompter.#getGuidelineRoot();
+    const filePath = `${guidelineRoot}/${guideName}/${guideName}.instruction.md`;
+    const content = await fsPromise.readFile(filePath, "utf-8");
+    return content;
+  }
+  static async getUpdateRequest(guideName: string) {
+    return await input({ message: `What do you want to update in ${guideName}?` });
+  }
+
+  async makeTsFileUpdatePrompt({ context, request }: FileUpdateRequestProps) {
+    return `You are a senior developer writing TypeScript-based programs using Akan.js, an in-house framework. Here's an overview of the Akan.js framework:
+${await this.getDocumentation("framework")}
+Please understand the following background information, write code that meets the requirements, verify that it satisfies the validation conditions, and return the result.
+
+# Background Information
+\`\`\`markdown
+${context}
+\`\`\`
+
+# Requirements
+\`\`\`markdown
+${request}
+\`\`\`
+`;
+  }
+  async getDocumentation(guideName: string) {
+    const guidelineRoot = await Prompter.#getGuidelineRoot();
+    const filePath = `${guidelineRoot}/${guideName}/${guideName}.instruction.md`;
+    const document = await fsPromise.readFile(filePath, "utf-8");
+    return `\`\`\`markdown
+${document}
+\`\`\`
+`;
+  }
+}