@akanjs/cli 2.1.1-rc.2 → 2.1.2-rc.0

package/incrementalBuilder.proc.js

@@ -205,11 +205,13 @@ class HttpClient {
 class CloudApi {
   #api;
   #accessToken = null;
-  static async fromHost(host) {
+  #workspace;
+  static async fromHost(workspace, host) {
     const hostConfig = await GlobalConfig.getHostConfig(host);
-    return new CloudApi(hostConfig);
+    return new CloudApi(workspace, hostConfig);
   }
-  constructor(hostConfig) {
+  constructor(workspace, hostConfig) {
+    this.#workspace = workspace;
     const host = akanCloudHost;
     this.#api = new HttpClient(`${host}/api`);
     this.#accessToken = hostConfig.auth?.accessToken ?? null;
@@ -225,16 +227,17 @@ class CloudApi {
     const data = await this.#api.post(`/uploadEnv/${devProjectId}`, formData);
     return data;
   }
-  async downloadEnv(devProjectId, localPath) {
+  async downloadEnv(devProjectId) {
+    const localPath = `${this.#workspace.workspaceRoot}/local/env.tar`;
     await this.#api.getFile(`/downloadEnv/${devProjectId}`, localPath);
   }
   async getRemoteAuthToken(remoteId) {
     try {
       if (this.#accessToken) {
         if (GlobalConfig.needRefreshToken(this.#accessToken))
-          return await this.refreshAuthToken();
+          return await this.#refreshAuthToken();
         else
-          return await this.refreshAuthToken();
+          return await this.#refreshAuthToken();
       }
       const accessToken = await this.#api.get(`/getRemoteAuthToken/${remoteId}`);
       this.#accessToken = GlobalConfig.toAccessToken(accessToken);
@@ -246,10 +249,14 @@ class CloudApi {
       return null;
     }
   }
-  async refreshAuthToken() {
-    const response = await this.#api.post(`/refreshRemoteAuthToken`, {
-      refreshToken: this.#accessToken?.refreshToken
-    });
+  async#refreshAuthToken() {
+    const refreshToken = this.#accessToken?.refreshToken;
+    if (!refreshToken)
+      throw new Error("No refresh token");
+    return await this.refreshAuthToken(refreshToken);
+  }
+  async refreshAuthToken(refreshToken) {
+    const response = await this.#api.post(`/refreshRemoteAuthToken`, { refreshToken });
     this.#accessToken = GlobalConfig.toAccessToken(response);
     this.#api.setHeaders({ Authorization: `Bearer ${this.#accessToken.jwt}` });
     return this.#accessToken;
@@ -329,6 +336,31 @@ var supportedLlmModels = [
   "deepseek-chat",
   "deepseek-reasoner"
 ];
+var parseTypescriptFileBlocks = (text) => {
+  const fileBlocks = [];
+  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;
+};
+var preserveTypescriptResponseContent = (previousContent, nextContent) => {
+  const previousWrites = parseTypescriptFileBlocks(previousContent);
+  const nextWrites = parseTypescriptFileBlocks(nextContent);
+  if (previousWrites.length > 0 && nextWrites.length === 0)
+    return previousContent;
+  return nextContent;
+};
 
 class AiSession {
   static #cacheDir = "node_modules/.cache/akan/aiSession";
@@ -448,7 +480,7 @@ class AiSession {
       const humanMessage = new HumanMessage(question);
       this.messageHistory.push(humanMessage);
       const stream = await AiSession.#chat.stream(this.messageHistory);
-      let reasoningResponse = "", fullResponse = "", tokenIdx = 0;
+      let reasoningResponse = "", fullResponse = "";
       for await (const chunk of stream) {
         if (loader.isSpinning())
           loader.succeed(`${AiSession.#chat.model} responded`);
@@ -469,7 +501,6 @@ class AiSession {
           fullResponse += content;
           onChunk(content);
         }
-        tokenIdx++;
       }
       fullResponse += `
 `;
@@ -477,7 +508,7 @@ class AiSession {
 `);
       this.messageHistory.push(new AIMessage(fullResponse));
       return { content: fullResponse, messageHistory: this.messageHistory };
-    } catch (error) {
+    } catch {
       loader.fail(`${AiSession.#chat.model} failed to respond`);
       throw new Error("Failed to stream response");
     }
@@ -487,7 +518,8 @@ class AiSession {
     onReasoning,
     maxTry = MAX_ASK_TRY,
     validate,
-    approve
+    approve,
+    fallbackToPreviousTypescript
   } = {}) {
     for (let tryCount = 0;tryCount < maxTry; tryCount++) {
       let response = await this.ask(question, { onChunk, onReasoning });
@@ -495,7 +527,14 @@ class AiSession {
         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(`
 `)}`;
-        response = await this.ask(validateQuestion, { onChunk, onReasoning });
+        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?",
@@ -528,15 +567,28 @@ ${validate.map((v) => `- ${v}`).join(`
     return this;
   }
   async writeTypescripts(question, executor, options = {}) {
-    const content = await this.edit(question, options);
+    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, options = {}) {
-    const content = await this.edit(question, options);
-    return this.#getTypescriptCodes(content);
+  async#editTypescripts(question, options = {}, fallbackWrites) {
+    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, executor, options = {}) {
     const MAX_EDIT_TRY = 5;
@@ -545,13 +597,15 @@ ${validate.map((v) => `- ${v}`).join(`
         prefix: `\uD83E\uDD16akan-editor`
       }).start();
       const fileChecks = await Promise.all(writes.map(async ({ filePath }) => {
-        const typeCheckResult = executor.typeCheck(filePath);
-        const lintResult = await executor.lint(filePath);
-        const needFix2 = !!typeCheckResult.fileErrors.length || !!lintResult.errors.length;
-        return { filePath, typeCheckResult, lintResult, needFix: needFix2 };
+        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 needFix = fileChecks.some((fileCheck) => fileCheck.needFix);
-      if (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) => {
           Logger2.rawLog(`TypeCheck Result 
@@ -567,7 +621,7 @@ ${fileCheck.lintResult.message}`);
           ...options,
           validate: undefined,
           approve: true
-        });
+        }, writes);
         for (const write of writes)
           await executor.writeFile(write.filePath, write.content);
       } else {
@@ -578,21 +632,7 @@ ${fileCheck.lintResult.message}`);
     throw new Error("Failed to create scalar");
   }
   #getTypescriptCodes(text) {
-    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}
-`, "").trim();
-      return { filePath, content: contentWithoutFilepath };
-    });
-    return result.filter((code) => code !== null);
+    return parseTypescriptFileBlocks(text);
   }
   async editMarkdown(request, options = {}) {
     const content = await this.edit(request, options);
@@ -610,13 +650,13 @@ ${fileCheck.lintResult.message}`);
 }
 // pkgs/@akanjs/devkit/akanApp/akanApp.host.ts
 import path9 from "path";
-import { Logger as Logger6 } from "akanjs/common";
+import { Logger as Logger5 } from "akanjs/common";
 
 // pkgs/@akanjs/devkit/executors.ts
 import {
   exec,
   fork,
-  spawn
+  spawn as spawn2
 } from "child_process";
 import { readFileSync as readFileSync3 } from "fs";
 import { copyFile, mkdir as mkdir2, readdir as readDirEntries, stat as stat2 } from "fs/promises";
@@ -624,7 +664,7 @@ import path7 from "path";
 import {
   capitalize,
   isRouteSourceFile,
-  Logger as Logger4,
+  Logger as Logger3,
   parseRouteModuleKey,
   validatePageSourceFile,
   validateSubRoutePageKey
@@ -671,8 +711,18 @@ var DEFAULT_OPTIMIZE_IMPORTS = [
   "mui-core",
   "react-icons/*"
 ];
-var WORKSPACE_BARREL_FACETS = ["ui", "webkit", "common", "client", "server"];
-var SSR_RUNTIME_PACKAGES = ["react", "react-dom", "react-server-dom-webpack"];
+var WORKSPACE_BARREL_FACETS = [
+  "ui",
+  "webkit",
+  "common",
+  "client",
+  "server"
+];
+var SSR_RUNTIME_PACKAGES = [
+  "react",
+  "react-dom",
+  "react-server-dom-webpack"
+];
 var NATIVE_RUNTIME_PACKAGES = ["sharp"];
 var DEFAULT_BACKEND_RUNTIME_PACKAGES = ["croner"];
 var DATABASE_MODE_RUNTIME_PACKAGES = {
@@ -732,7 +782,12 @@ class AkanAppConfig {
       ...libs.flatMap((lib) => WORKSPACE_BARREL_FACETS.map((facet) => `@libs/${lib}/${facet}`)),
       ...config?.barrelImports ?? []
     ];
-    this.optimizeImports = [...new Set([...DEFAULT_OPTIMIZE_IMPORTS, ...config?.optimizeImports ?? []])];
+    this.optimizeImports = [
+      ...new Set([
+        ...DEFAULT_OPTIMIZE_IMPORTS,
+        ...config?.optimizeImports ?? []
+      ])
+    ];
     this.images = mergeImageConfig(config?.images);
     this.i18n = resolveAkanI18nConfig(config?.i18n);
     process.env.AKAN_PUBLIC_DEFAULT_LOCALE = this.i18n.defaultLocale;
@@ -843,7 +898,13 @@ class AkanAppConfig {
   }
   #makeDockerContent(docker) {
     if (docker.content)
-      return { content: docker.content, image: {}, preRuns: [], postRuns: [], command: [] };
+      return {
+        content: docker.content,
+        image: {},
+        preRuns: [],
+        postRuns: [],
+        command: []
+      };
     const preRunScripts = this.#getDockerRunScripts(docker.preRuns ?? []);
     const postRunScripts = this.#getDockerRunScripts(docker.postRuns ?? []);
     const imageScript = docker.image ? this.#getDockerImageScript(docker.image, "oven/bun:1-slim") : "FROM oven/bun:1-slim";
@@ -874,7 +935,13 @@ ENV AKAN_PUBLIC_LOCALES=${this.i18n.locales.join(",")}
 ENV AKAN_PUBLIC_OPERATION_MODE=cloud
 
 CMD [${command.map((c) => `"${c}"`).join(",")}]`;
-    return { content, image: imageScript, preRuns: docker.preRuns ?? [], postRuns: docker.postRuns ?? [], command };
+    return {
+      content,
+      image: imageScript,
+      preRuns: docker.preRuns ?? [],
+      postRuns: docker.postRuns ?? [],
+      command
+    };
   }
   static async from(app) {
     const [configImp, baseDevEnv, libs, rootPackageJson] = await Promise.all([
@@ -900,9 +967,24 @@ CMD [${command.map((c) => `"${c}"`).join(",")}]`;
       ...SSR_RUNTIME_PACKAGES,
       ...NATIVE_RUNTIME_PACKAGES,
       ...DEFAULT_BACKEND_RUNTIME_PACKAGES,
-      ...DATABASE_MODE_RUNTIME_PACKAGES[this.defaultDatabaseMode]
+      ...this.getDatabaseModeRuntimePackages()
     ];
   }
+  getDatabaseModeRuntimePackages(databaseMode = this.defaultDatabaseMode) {
+    return [...DATABASE_MODE_RUNTIME_PACKAGES[databaseMode]];
+  }
+  getMissingDatabaseModeDependencySpecs(databaseMode = this.defaultDatabaseMode) {
+    const rootDependencies = {
+      ...this.rootPackageJson.dependencies,
+      ...this.rootPackageJson.devDependencies
+    };
+    return this.getDatabaseModeRuntimePackages(databaseMode).filter((lib) => !rootDependencies[lib]).map((lib) => {
+      const version = this.#resolveProductionDependencyVersion(lib);
+      if (!version)
+        throw new Error(`Dependency ${lib} not found in package.json`);
+      return `${lib}@${version}`;
+    });
+  }
   getProductionPackageJson(data = {}) {
     return {
       name: this.app.name,
@@ -938,7 +1020,12 @@ function getAkanPackageJson() {
       return akanPackageJson;
     } catch {}
   }
-  akanPackageJson = { name: "akanjs", version: "0.0.0", description: "akanjs", dependencies: {} };
+  akanPackageJson = {
+    name: "akanjs",
+    version: "0.0.0",
+    description: "akanjs",
+    dependencies: {}
+  };
   return akanPackageJson;
 }
 function mergeImageConfig(config = {}) {
@@ -962,7 +1049,9 @@ class AkanLibConfig {
     this.externalLibs = config?.externalLibs ?? [];
   }
   static async from(lib) {
-    const [configImp] = await Promise.all([import(`${lib.cwdPath}/akan.config.ts`).then((mod) => mod.default)]);
+    const [configImp] = await Promise.all([
+      import(`${lib.cwdPath}/akan.config.ts`).then((mod) => mod.default)
+    ]);
     const config = typeof configImp === "function" ? configImp(lib) : configImp;
     return new AkanLibConfig(lib, config);
   }
@@ -987,23 +1076,146 @@ import path2 from "path";
 var getDirname = (url) => path2.dirname(new URL(url).pathname);
 
 // pkgs/@akanjs/devkit/linter.ts
+import { spawn } from "child_process";
 import { existsSync, readFileSync } from "fs";
-import * as path3 from "path";
-import { Logger as Logger3 } from "akanjs/common";
+import path3 from "path";
 import chalk2 from "chalk";
 
 class Linter {
-  #logger = new Logger3("Linter");
   lintRoot;
+  #biomeBin;
   constructor(cwdPath) {
-    this.lintRoot = this.#findEslintRootPath(cwdPath);
+    this.lintRoot = this.#findBiomeRootPath(cwdPath);
+    const localBiomeBin = path3.join(this.lintRoot, "node_modules/.bin/biome");
+    this.#biomeBin = existsSync(localBiomeBin) ? localBiomeBin : "biome";
   }
-  #findEslintRootPath(dir) {
-    const configPath2 = path3.join(dir, "eslint.config.ts");
+  #findBiomeRootPath(dir) {
+    const configPath2 = path3.join(dir, "biome.json");
     if (existsSync(configPath2))
       return dir;
     const parentDir = path3.dirname(dir);
-    return this.#findEslintRootPath(parentDir);
+    if (parentDir === dir)
+      throw new Error(`biome.json not found from ${dir}`);
+    return this.#findBiomeRootPath(parentDir);
+  }
+  #toBiomePath(filePath) {
+    const relativePath = path3.relative(this.lintRoot, filePath);
+    if (!relativePath.startsWith("..") && !path3.isAbsolute(relativePath))
+      return relativePath;
+    return filePath;
+  }
+  #resolveFilePath(filePath) {
+    return path3.isAbsolute(filePath) ? filePath : path3.join(this.lintRoot, filePath);
+  }
+  async#runBiome(args, input2) {
+    return await new Promise((resolve, reject) => {
+      const proc = spawn(this.#biomeBin, args, {
+        cwd: this.lintRoot,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("error", reject);
+      proc.on("close", (code) => resolve({ stdout, stderr, code }));
+      proc.stdin.end(input2);
+    });
+  }
+  #parseBiomeReport(output) {
+    const jsonStart = output.indexOf("{");
+    const jsonEnd = output.lastIndexOf("}");
+    if (jsonStart === -1 || jsonEnd === -1 || jsonEnd < jsonStart)
+      throw new Error(output.trim() || "No Biome JSON output");
+    return JSON.parse(output.slice(jsonStart, jsonEnd + 1));
+  }
+  #diagnosticFilePath(diagnostic, fallbackFilePath) {
+    const diagnosticPath = diagnostic.location?.path;
+    if (!diagnosticPath)
+      return fallbackFilePath;
+    return path3.isAbsolute(diagnosticPath) ? diagnosticPath : path3.join(this.lintRoot, diagnosticPath);
+  }
+  #createLintMessage(diagnostic) {
+    const start = diagnostic.location?.start;
+    const end = diagnostic.location?.end;
+    return {
+      line: Math.max(1, start?.line ?? 1),
+      column: Math.max(1, start?.column ?? 1),
+      endLine: end?.line,
+      endColumn: end?.column,
+      message: diagnostic.message,
+      ruleId: diagnostic.category ?? null,
+      severity: diagnostic.severity === "error" ? 2 : 1
+    };
+  }
+  #toLintResults(report, filePath) {
+    const resultsByPath = new Map;
+    for (const diagnostic of report.diagnostics ?? []) {
+      if (diagnostic.severity !== "error" && diagnostic.severity !== "warning")
+        continue;
+      const diagnosticFilePath = this.#diagnosticFilePath(diagnostic, filePath);
+      const result = resultsByPath.get(diagnosticFilePath) ?? {
+        filePath: diagnosticFilePath,
+        messages: [],
+        errorCount: 0,
+        warningCount: 0,
+        fixableErrorCount: 0,
+        fixableWarningCount: 0
+      };
+      const message = this.#createLintMessage(diagnostic);
+      result.messages.push(message);
+      if (message.severity === 2)
+        result.errorCount += 1;
+      else
+        result.warningCount += 1;
+      resultsByPath.set(diagnosticFilePath, result);
+    }
+    return [
+      resultsByPath.get(filePath) ?? {
+        filePath,
+        messages: [],
+        errorCount: 0,
+        warningCount: 0,
+        fixableErrorCount: 0,
+        fixableWarningCount: 0
+      },
+      ...[...resultsByPath.entries()].filter(([resultPath]) => resultPath !== filePath).map(([, result]) => result)
+    ];
+  }
+  #splitMessages(results) {
+    const messages = results.flatMap((result) => result.messages);
+    return {
+      errors: messages.filter((message) => message.severity === 2),
+      warnings: messages.filter((message) => message.severity === 1)
+    };
+  }
+  async#checkFile(filePath, { write = false } = {}) {
+    const originalContent = existsSync(filePath) ? readFileSync(filePath, "utf8") : "";
+    const { stdout, stderr } = await this.#runBiome([
+      "check",
+      ...write ? ["--write"] : [],
+      "--reporter=json",
+      "--max-diagnostics=none",
+      "--no-errors-on-unmatched",
+      "--config-path",
+      path3.join(this.lintRoot, "biome.json"),
+      this.#toBiomePath(filePath)
+    ]);
+    const report = this.#parseBiomeReport(stdout || stderr);
+    const results = this.#toLintResults(report, filePath);
+    const { errors, warnings } = this.#splitMessages(results);
+    const output = write && existsSync(filePath) ? readFileSync(filePath, "utf8") : undefined;
+    return {
+      fixed: write && output !== originalContent,
+      output,
+      results,
+      errors,
+      warnings
+    };
   }
   async lint(filePath, { fix = false, dryRun = false } = {}) {
     if (fix)
@@ -1011,9 +1223,10 @@ class Linter {
     return await this.lintFile(filePath);
   }
   async lintFile(filePath) {
-    if (!existsSync(filePath))
+    const resolvedFilePath = this.#resolveFilePath(filePath);
+    if (!existsSync(resolvedFilePath))
       throw new Error(`File not found: ${filePath}`);
-    return { fixed: false, results: [], errors: [], warnings: [] };
+    return await this.#checkFile(resolvedFilePath);
   }
   formatLintResults(results) {
     if (results.length === 0)
@@ -1033,12 +1246,12 @@ ${chalk2.cyan(result.filePath)}`);
             const sourceContent = readFileSync(result.filePath, "utf8");
             sourceLines = sourceContent.split(`
 `);
-          } catch (error) {}
+          } catch {}
         }
         result.messages.forEach((message) => {
           const type = message.severity === 2 ? "error" : "warning";
           const typeColor = message.severity === 2 ? chalk2.red : chalk2.yellow;
-          const icon = message.severity === 2 ? "\u274C" : "\u26A0\uFE0F";
+          const icon = message.severity === 2 ? "x" : "!";
           const ruleInfo = message.ruleId ? chalk2.dim(` (${message.ruleId})`) : "";
           output.push(`
   ${icon} ${typeColor(type)}: ${message.message}${ruleInfo}`);
@@ -1057,7 +1270,7 @@ ${chalk2.dim(`${lineNumber} |`)} ${sourceLine}`);
       }
     });
     if (totalErrors === 0 && totalWarnings === 0)
-      return chalk2.bold("\u2705 No ESLint errors or warnings found");
+      return chalk2.bold("No Biome errors or warnings found");
     const errorText = totalErrors > 0 ? chalk2.red(`${totalErrors} error(s)`) : "0 errors";
     const warningText = totalWarnings > 0 ? chalk2.yellow(`${totalWarnings} warning(s)`) : "0 warnings";
     const summary = [`
@@ -1072,23 +1285,26 @@ ${errorText}, ${warningText} found`];
       column: message.column,
       message: message.message,
       ruleId: message.ruleId,
-      severity: message.severity === 2 ? "error" : "warning",
-      fix: message.fix,
-      suggestions: message.suggestions
+      severity: message.severity === 2 ? "error" : "warning"
     })));
     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 });
+    }), {
+      errorCount: 0,
+      warningCount: 0,
+      fixableErrorCount: 0,
+      fixableWarningCount: 0
+    });
     return { results, details, stats };
   }
   async hasNoLintErrors(filePath) {
     try {
       const { results } = await this.lintFile(filePath);
       return results.every((result) => result.errorCount === 0);
-    } catch (error) {
+    } catch {
       return false;
     }
   }
@@ -1101,12 +1317,28 @@ ${errorText}, ${warningText} found`];
     return results.flatMap((result) => result.messages.filter((message) => message.severity === 1));
   }
   async fixFile(filePath, dryRun = false) {
-    if (!existsSync(filePath))
+    const resolvedFilePath = this.#resolveFilePath(filePath);
+    if (!existsSync(resolvedFilePath))
       throw new Error(`File not found: ${filePath}`);
-    return { fixed: false, output: undefined, results: [], errors: [], warnings: [] };
+    if (!dryRun)
+      return await this.#checkFile(resolvedFilePath, { write: true });
+    const source = readFileSync(resolvedFilePath, "utf8");
+    const { stdout } = await this.#runBiome([
+      "check",
+      "--write",
+      "--config-path",
+      path3.join(this.lintRoot, "biome.json"),
+      "--stdin-file-path",
+      this.#toBiomePath(resolvedFilePath)
+    ], source);
+    const lintResult = await this.lintFile(resolvedFilePath);
+    return { ...lintResult, fixed: stdout !== source, output: stdout };
   }
   async getConfigForFile(filePath) {
-    return {};
+    const resolvedFilePath = this.#resolveFilePath(filePath);
+    if (!existsSync(resolvedFilePath))
+      throw new Error(`File not found: ${filePath}`);
+    return JSON.parse(readFileSync(path3.join(this.lintRoot, "biome.json"), "utf8"));
   }
   async getProblematicRules(filePath) {
     const { results } = await this.lintFile(filePath);
@@ -1496,23 +1728,23 @@ async function assertScanConvention(exec, libRoot) {
     files.filter((filename) => !appRootAllowedFiles.has(filename)).forEach((filename) => {
       addViolation(filename, "unsupported app root file");
     });
-    dirs.filter((dirname2) => !appRootAllowedDirs.has(dirname2)).forEach((dirname2) => {
-      addViolation(dirname2, "unsupported app root folder");
+    dirs.filter((dirname) => !appRootAllowedDirs.has(dirname)).forEach((dirname) => {
+      addViolation(dirname, "unsupported app root folder");
     });
   }
   libRoot.files.filter((filename) => !isAllowedLibRootFile(filename)).forEach((filename) => {
     addViolation(path5.join("lib", filename), "unsupported lib root file");
   });
-  libRoot.dirs.filter((dirname2) => dirname2.startsWith("__") && !internalLibDirs.has(dirname2)).forEach((dirname2) => {
-    addViolation(path5.join("lib", dirname2), "unsupported internal lib folder");
+  libRoot.dirs.filter((dirname) => dirname.startsWith("__") && !internalLibDirs.has(dirname)).forEach((dirname) => {
+    addViolation(path5.join("lib", dirname), "unsupported internal lib folder");
   });
-  const databaseDirs = libRoot.dirs.filter((dirname2) => !dirname2.startsWith("_"));
-  const serviceDirs = libRoot.dirs.filter((dirname2) => dirname2.startsWith("_") && !dirname2.startsWith("__"));
+  const databaseDirs = libRoot.dirs.filter((dirname) => !dirname.startsWith("_"));
+  const serviceDirs = libRoot.dirs.filter((dirname) => dirname.startsWith("_") && !dirname.startsWith("__"));
   const scalarDirs = await exec.readdir("lib/__scalar");
   await Promise.all([
-    ...databaseDirs.map((dirname2) => validateModuleFiles(exec, violations, "database", path5.join("lib", dirname2))),
-    ...serviceDirs.map((dirname2) => validateModuleFiles(exec, violations, "service", path5.join("lib", dirname2))),
-    ...scalarDirs.map((dirname2) => validateModuleFiles(exec, violations, "scalar", path5.join("lib/__scalar", dirname2)))
+    ...databaseDirs.map((dirname) => validateModuleFiles(exec, violations, "database", path5.join("lib", dirname))),
+    ...serviceDirs.map((dirname) => validateModuleFiles(exec, violations, "service", path5.join("lib", dirname))),
+    ...scalarDirs.map((dirname) => validateModuleFiles(exec, violations, "scalar", path5.join("lib/__scalar", dirname)))
   ]);
   if (violations.length > 0) {
     throw new Error(`[scan-convention]
@@ -1522,8 +1754,8 @@ ${violations.sort().map((violation) => `- ${violation}`).join(`
 }
 async function validateModuleFiles(exec, violations, kind, modulePath) {
   const { files, dirs } = await exec.getFilesAndDirs(modulePath);
-  dirs.forEach((dirname2) => {
-    violations.push(`${getScanPath(exec, path5.join(modulePath, dirname2))}: unsupported module folder`);
+  dirs.forEach((dirname) => {
+    violations.push(`${getScanPath(exec, path5.join(modulePath, dirname))}: unsupported module folder`);
   });
   files.forEach((filename) => {
     const filePath = path5.join(modulePath, filename);
@@ -1622,9 +1854,9 @@ class ScanInfo {
             files.zone.databases.push(name);
         });
       }),
-      ...serviceDirs.map(async (dirname2) => {
-        const name = dirname2.slice(1);
-        const filenames = await exec.readdir(path5.join("lib", dirname2));
+      ...serviceDirs.map(async (dirname) => {
+        const name = dirname.slice(1);
+        const filenames = await exec.readdir(path5.join("lib", dirname));
         filenames.forEach((filename) => {
           if (filename.endsWith(".dictionary.ts"))
             files.dictionary.services.push(name);
@@ -2254,9 +2486,11 @@ var ROOT_LAYOUT_EXPORTS = new Set([
   "reconnect",
   "layoutStyle",
   "gaTrackingId",
-  "Loading"
+  "Loading",
+  "NotFound",
+  "Error"
 ]);
-var LAYOUT_ROUTE_EXPORTS = new Set(["default", "head", "generateHead", "Loading"]);
+var LAYOUT_ROUTE_EXPORTS = new Set(["default", "head", "generateHead", "Loading", "NotFound", "Error"]);
 function validateRouteSourceExports(source, filePath, kind, options = {}) {
   const sourceFile = ts3.createSourceFile(filePath, source, ts3.ScriptTarget.Latest, true, ts3.ScriptKind.TSX);
   const allowed = kind === "page" ? PAGE_ROUTE_EXPORTS : options.rootLayout ? ROOT_LAYOUT_EXPORTS : LAYOUT_ROUTE_EXPORTS;
@@ -2325,16 +2559,16 @@ class Executor {
   linter = null;
   constructor(name, cwdPath) {
     this.name = name;
-    this.logger = new Logger4(name);
+    this.logger = new Logger3(name);
     this.logs = [];
     this.cwdPath = cwdPath;
   }
   #stdout(data) {
     if (Executor.verbose)
-      Logger4.raw(chalk4.dim(data.toString()));
+      Logger3.raw(chalk4.dim(data.toString()));
   }
   #stderr(data) {
-    Logger4.raw(chalk4.red(data.toString()));
+    Logger3.raw(chalk4.red(data.toString()));
   }
   exec(command, options = {}) {
     const cwd = options.cwd?.toString() ?? this.cwdPath;
@@ -2378,7 +2612,7 @@ class Executor {
   }
   spawn(command, args = [], options = {}) {
     const cwd = options.cwd?.toString() ?? this.cwdPath;
-    const proc = spawn(command, args, {
+    const proc = spawn2(command, args, {
       cwd: this.cwdPath,
       ...options
     });
@@ -2424,7 +2658,7 @@ class Executor {
     });
   }
   spawnSync(command, args = [], options = {}) {
-    const proc = spawn(command, args, {
+    const proc = spawn2(command, args, {
       cwd: this.cwdPath,
       ...options
     });
@@ -2556,7 +2790,7 @@ class Executor {
         contentStr = currentContent;
       } else {
         await FileSys.writeText(writePath, contentStr);
-        if (Logger4.isVerbose())
+        if (Logger3.isVerbose())
           this.logger.rawLog(chalk4.yellow(`File Update: ${filePath}`));
       }
     } else {
@@ -2665,8 +2899,8 @@ class Executor {
         return null;
       const filename = typeof result === "object" ? result.filename : path7.basename(targetPath).replace(".js", ".ts");
       const content = typeof result === "object" ? result.content : result;
-      const dirname3 = path7.dirname(targetPath);
-      const convertedTargetPath = Object.entries(dict).reduce((path8, [key, value]) => path8.replace(new RegExp(`__${key}__`, "g"), value), `${dirname3}/${filename}`);
+      const dirname2 = path7.dirname(targetPath);
+      const convertedTargetPath = Object.entries(dict).reduce((path8, [key, value]) => path8.replace(new RegExp(`__${key}__`, "g"), value), `${dirname2}/${filename}`);
       this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
       return this.writeFile(convertedTargetPath, content, { overwrite });
     } else if (targetPath.endsWith(".template")) {
@@ -2680,9 +2914,9 @@ class Executor {
     } else if (staticTemplateFileExtensions.has(path7.extname(targetPath).toLowerCase())) {
       const convertedTargetPath = Object.entries(dict).reduce((path8, [key, value]) => path8.replace(new RegExp(`__${key}__`, "g"), value), targetPath);
       const writePath = this.getPath(convertedTargetPath);
-      const dirname3 = path7.dirname(writePath);
-      if (!await FileSys.dirExists(dirname3))
-        await mkdir2(dirname3, { recursive: true });
+      const dirname2 = path7.dirname(writePath);
+      if (!await FileSys.dirExists(dirname2))
+        await mkdir2(dirname2, { recursive: true });
       await copyFile(templatePath, writePath);
       this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
       return { filePath: writePath, content: "" };
@@ -2763,6 +2997,48 @@ class Executor {
     const message = typeChecker.formatDiagnostics(fileDiagnostics);
     return { fileDiagnostics, fileErrors, fileWarnings, message };
   }
+  async typeCheckAsync(filePath) {
+    const path8 = this.getPath(filePath);
+    const entry = await this.#resolveTypecheckWorkerEntry();
+    const proc = Bun.spawn([process.execPath, entry], {
+      cwd: this.cwdPath,
+      env: {
+        ...process.env,
+        AKAN_TYPECHECK_CWD: this.cwdPath,
+        AKAN_TYPECHECK_FILE: path8
+      },
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited
+    ]);
+    if (exitCode !== 0)
+      throw new Error((stderr || stdout).trim() || `Typecheck failed with exit code ${exitCode}`);
+    const result = JSON.parse(stdout);
+    return {
+      fileDiagnostics: Array.from({ length: result.fileDiagnosticsCount }),
+      fileErrors: Array.from({ length: result.fileErrorsCount }),
+      fileWarnings: Array.from({ length: result.fileWarningsCount }),
+      message: result.message
+    };
+  }
+  async#resolveTypecheckWorkerEntry() {
+    const dirname2 = getDirname(import.meta.url);
+    const candidates = [
+      path7.join(process.cwd(), "pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path7.join(process.cwd(), "node_modules/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path7.join(dirname2, "typecheck/typecheck.proc.ts"),
+      path7.join(dirname2, "typecheck.proc.js"),
+      path7.join(dirname2, "typecheck.proc.ts")
+    ];
+    for (const candidate of candidates)
+      if (await Bun.file(candidate).exists())
+        return candidate;
+    throw new Error(`[devkit] typecheck worker entry not found; looked in: ${candidates.join(", ")}`);
+  }
   getLinter() {
     this.linter ??= new Linter(this.cwdPath);
     return this.linter;
@@ -2810,7 +3086,15 @@ class WorkspaceExecutor extends Executor {
     const env = sourceEnv.AKAN_PUBLIC_ENV ?? "debug";
     if (!env)
       throw new Error("AKAN_PUBLIC_ENV is not set");
-    return { ...appName ? { appName } : {}, workspaceRoot, repoName, serveDomain, env, portOffset, workspaceId };
+    return {
+      ...appName ? { appName } : {},
+      workspaceRoot,
+      repoName,
+      serveDomain,
+      env,
+      portOffset,
+      workspaceId
+    };
   }
   getWorkspaceId({
     allowEmpty
@@ -2870,12 +3154,12 @@ class WorkspaceExecutor extends Executor {
   }
   async getDirInModule(basePath2, name) {
     const AVOID_DIRS = ["__lib", "__scalar", `_`, `_${name}`];
-    const getDirs = async (dirname3, maxDepth = 3, results = [], prefix = "") => {
-      const dirs = await this.readdir(dirname3);
+    const getDirs = async (dirname2, maxDepth = 3, results = [], prefix = "") => {
+      const dirs = await this.readdir(dirname2);
       await Promise.all(dirs.map(async (dir) => {
         if (dir.includes("_") || AVOID_DIRS.includes(dir))
           return;
-        const dirPath = path7.join(dirname3, dir);
+        const dirPath = path7.join(dirname2, dir);
         if ((await stat2(dirPath)).isDirectory()) {
           results.push(`${prefix}${dir}`);
           if (maxDepth > 0)
@@ -2895,12 +3179,12 @@ class WorkspaceExecutor extends Executor {
   }
   async#getDirHasFile(basePath2, targetFilename) {
     const AVOID_DIRS = ["node_modules", "dist", "public", "webkit"];
-    const getDirs = async (dirname3, maxDepth = 3, results = [], prefix = "") => {
-      const dirs = await this.readdir(dirname3);
+    const getDirs = async (dirname2, maxDepth = 3, results = [], prefix = "") => {
+      const dirs = await this.readdir(dirname2);
       await Promise.all(dirs.map(async (dir) => {
         if (AVOID_DIRS.includes(dir))
           return;
-        const dirPath = path7.join(dirname3, dir);
+        const dirPath = path7.join(dirname2, dir);
         if ((await stat2(dirPath)).isDirectory()) {
           const hasTargetFile = await FileSys.fileExists(path7.join(dirPath, targetFilename));
           if (hasTargetFile)
@@ -3165,6 +3449,13 @@ class AppExecutor extends SysExecutor {
   getEnv() {
     return WorkspaceExecutor.getBaseDevEnv().env;
   }
+  async getDevPort() {
+    const basePort = 8282;
+    const appNames = (await this.workspace.getApps()).sort((a, b) => a.localeCompare(b));
+    const appIndex = Math.max(appNames.indexOf(this.name), 0);
+    const portOffset = WorkspaceExecutor.getBaseDevEnv().portOffset;
+    return basePort + appIndex + portOffset;
+  }
   getCommandEnv(env = {}) {
     const basePort = 8282;
     const portOffset = WorkspaceExecutor.getBaseDevEnv().portOffset;
@@ -3198,7 +3489,12 @@ class AppExecutor extends SysExecutor {
       ]);
     } else
       await this.removeDir(".akan");
-    const env = this.getCommandEnv({ AKAN_COMMAND_TYPE: type, ...routeEnv });
+    const devPort = type === "start" ? (await this.getDevPort()).toString() : undefined;
+    const env = this.getCommandEnv({
+      AKAN_COMMAND_TYPE: type,
+      ...routeEnv,
+      ...devPort ? { PORT: devPort, AKAN_PUBLIC_CLIENT_PORT: devPort, AKAN_PUBLIC_SERVER_PORT: devPort } : {}
+    });
     return { env };
   }
   #publicEnv = null;
@@ -3617,7 +3913,7 @@ var createTunnel = async (service, { app, environment, port = service === "postg
 
 // pkgs/@akanjs/devkit/incrementalBuilder/incrementalBuilder.host.ts
 import path8 from "path";
-import { Logger as Logger5 } from "akanjs/common";
+import { Logger as Logger4 } from "akanjs/common";
 var builderMsgTypeSet = new Set([
   "build-route-res",
   "builder-ready",
@@ -3629,7 +3925,7 @@ var builderMsgTypeSet = new Set([
 class IncrementalBuilderHost {
   static #restartBaseDelayMs = 1000;
   static #restartMaxDelayMs = 30000;
-  logger = new Logger5("IncrementalBuilderHost");
+  logger = new Logger4("IncrementalBuilderHost");
   entry;
   env;
   app;
@@ -3877,7 +4173,7 @@ class BackendImportGraph {
 
 class AkanAppHost {
   app;
-  logger = new Logger6("AkanAppHost");
+  logger = new Logger5("AkanAppHost");
   withInk;
   env;
   #backend = null;
@@ -4160,19 +4456,19 @@ class AkanAppHost {
   }
 }
 // pkgs/@akanjs/devkit/applicationBuildReporter.ts
-import { Logger as Logger7 } from "akanjs/common";
+import { Logger as Logger6 } from "akanjs/common";
 
 class ApplicationBuildReporter {
   static create() {
     return {
-      phaseDone: (phase) => Logger7.rawLog(ApplicationBuildReporter.formatPhaseLine(phase))
+      phaseDone: (phase) => Logger6.rawLog(ApplicationBuildReporter.formatPhaseLine(phase))
     };
   }
   static printSummary(result) {
-    Logger7.rawLog("");
-    Logger7.rawLog(`Route artifacts: ${result.artifactDir}`);
-    Logger7.rawLog(`Server output: ${result.outputDir}`);
-    Logger7.rawLog(`Done in ${ApplicationBuildReporter.formatDuration(result.durationMs)}`);
+    Logger6.rawLog("");
+    Logger6.rawLog(`Route artifacts: ${result.artifactDir}`);
+    Logger6.rawLog(`Server output: ${result.outputDir}`);
+    Logger6.rawLog(`Done in ${ApplicationBuildReporter.formatDuration(result.durationMs)}`);
   }
   static formatError(error) {
     if (error instanceof AggregateError) {
@@ -4324,6 +4620,9 @@ export async function generateHead(props: PageProps) {
   return inheritedLayout.head;
 }
 
+export const NotFound = userLayout.NotFound ?? inheritedLayout.NotFound;
+export const Error = userLayout.Error ?? inheritedLayout.Error;
+
 export default function GeneratedLayout({ children, params, searchParams }: LayoutProps) {
   return (
     <System.Provider
@@ -4353,6 +4652,9 @@ export async function generateHead(props: PageProps) {
   return inheritedLayout.head;
 }
 
+export const NotFound = userLayout.NotFound ?? inheritedLayout.NotFound;
+export const Error = userLayout.Error ?? inheritedLayout.Error;
+
 export default function GeneratedLayout({ children, params, searchParams }: LayoutProps) {
   return <UserLayout params={params} searchParams={searchParams}>{children}</UserLayout>;
 }
@@ -4471,13 +4773,13 @@ import path14 from "path";
 
 // pkgs/@akanjs/devkit/transforms/barrelAnalyzer.ts
 import path12 from "path";
-import { Logger as Logger8 } from "akanjs/common";
+import { Logger as Logger7 } from "akanjs/common";
 var REEXPORT_RE = /(?:^|\n)\s*export\s+(?:type\s+)?(?:(\*)(?:\s+as\s+(\w+))?|\{\s*([^}]*?)\s*\})\s+from\s+(["'])([^"']+)\4;?/g;
 var LOCAL_NAMED_RE = /(?:^|\n)\s*export\s+\{\s*([^}]*?)\s*\}(?!\s*from)/g;
 var CANDIDATE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
 
 class BarrelAnalyzer {
-  #logger = new Logger8("BarrelAnalyzer");
+  #logger = new Logger7("BarrelAnalyzer");
   #opts;
   #cache = new Map;
   #tsTranspiler = new Bun.Transpiler({ loader: "ts" });
@@ -6177,7 +6479,7 @@ ${CsrArtifactBuilder.escapeInlineScript(await loadScript(src))}
 }
 // pkgs/@akanjs/devkit/frontendBuild/cssCompiler.ts
 import path23 from "path";
-import { Logger as Logger9 } from "akanjs/common";
+import { Logger as Logger8 } from "akanjs/common";
 import { compile } from "tailwindcss";
 
 // pkgs/@akanjs/devkit/frontendBuild/cssImportResolver.ts
@@ -6322,7 +6624,7 @@ var NODE_MODULES_RE3 = /[\\/]node_modules[\\/]/;
 var AKANJS_NODE_MODULE_RE3 = /[\\/]node_modules[\\/]akanjs[\\/]/;
 
 class CssCompiler {
-  #logger = new Logger9("CssCompiler");
+  #logger = new Logger8("CssCompiler");
   #transpiler = new Bun.Transpiler({ loader: "tsx" });
   #app;
   #cssImportResolver = null;
@@ -7730,7 +8032,7 @@ class ApplicationBuildRunner {
 import { cp, mkdir as mkdir8, rm as rm3 } from "fs/promises";
 
 // pkgs/@akanjs/devkit/uploadRelease.ts
-import { HttpClient as HttpClient2, Logger as Logger10 } from "akanjs/common";
+import { HttpClient as HttpClient2, Logger as Logger9 } from "akanjs/common";
 var spinning = (message) => {
   const spinner = new Spinner(message, { prefix: message, enableSpin: true }).start();
   return spinner;
@@ -7743,7 +8045,7 @@ var uploadRelease = async (appName, {
   os,
   local
 }) => {
-  const logger = new Logger10("uploadRelease");
+  const logger = new Logger9("uploadRelease");
   const basePath2 = local ? "http://localhost:8282/backend" : "https://cloud.akanjs.com/backend";
   const httpClient = new HttpClient2(basePath2);
   const buildPath = `${workspaceRoot}/releases/builds/${appName}-release.tar.gz`;
@@ -8729,7 +9031,7 @@ var Workspace = createInternalArgToken("Workspace");
 // pkgs/@akanjs/devkit/commandDecorators/command.ts
 import path36 from "path";
 import { confirm, input as input2, select as select2 } from "@inquirer/prompts";
-import { Logger as Logger11 } from "akanjs/common";
+import { Logger as Logger10 } from "akanjs/common";
 import chalk6 from "chalk";
 import { program } from "commander";
 
@@ -9014,7 +9316,7 @@ var printCliError = (error) => {
   if (loggedCliErrorMessages.has(message))
     return;
   loggedCliErrorMessages.add(message);
-  Logger11.rawLog(`
+  Logger10.rawLog(`
 ${chalk6.red(message)}`);
 };
 var handleOption = (programCommand, argMeta) => {
@@ -9243,7 +9545,7 @@ var runCommands = async (...commands) => {
   const hasCommand = process.argv.length > 2 && !process.argv[2]?.startsWith("-");
   if (hasHelpFlag || !hasCommand) {
     if (process.argv.length === 2 || process.argv.length === 3 && hasHelpFlag) {
-      Logger11.rawLog(formatHelp(commands, process.env.AKAN_VERSION));
+      Logger10.rawLog(formatHelp(commands, process.env.AKAN_VERSION));
       process.exit(0);
     }
   }
@@ -9252,7 +9554,7 @@ var runCommands = async (...commands) => {
   });
   const installedAkanPackageJson = await FileSys.fileExists("./node_modules/akanjs/package.json") ? await FileSys.readJson("./node_modules/akanjs/package.json") : null;
   if (installedAkanPackageJson && installedAkanPackageJson.version !== process.env.AKAN_VERSION) {
-    Logger11.rawLog(chalk6.yellow(`
+    Logger10.rawLog(chalk6.yellow(`
 Akan CLI version is mismatch with installed package. ${process.env.AKAN_VERSION} (global) vs ${installedAkanPackageJson.version} (akanjs)
 It may cause unexpected behavior. Run \`akan update\` to update latest akanjs.`));
   }
@@ -9288,7 +9590,7 @@ It may cause unexpected behavior. Run \`akan update\` to update latest akanjs.`)
           return formatCommandHelp(command, targetMeta.key);
         };
         programCommand.action(async (...args) => {
-          Logger11.rawLog();
+          Logger10.rawLog();
           const cmdArgs = args.slice(0, args.length - 2);
           const opt = args[args.length - 2];
           const commandArgs = [];
@@ -9312,7 +9614,7 @@ It may cause unexpected behavior. Run \`akan update\` to update latest akanjs.`)
           const cmd = CommandContainer.get(command);
           try {
             await targetMeta.handler.call(cmd, ...commandArgs);
-            Logger11.rawLog();
+            Logger10.rawLog();
           } catch (e) {
             printCliError(e);
             throw e;
@@ -9652,8 +9954,11 @@ import fsPromise from "fs/promises";
 import { input as input3, select as select3 } from "@inquirer/prompts";
 class Prompter {
   static async#getGuidelineRoot() {
-    const dirname3 = getDirname(import.meta.url);
-    const candidates = [`${dirname3}/guidelines`, `${dirname3}/../cli/guidelines`];
+    const dirname2 = getDirname(import.meta.url);
+    const candidates = [
+      `${dirname2}/guidelines`,
+      `${dirname2}/../cli/guidelines`
+    ];
     for (const candidate of candidates) {
       try {
         await fsPromise.access(candidate);
@@ -9665,7 +9970,10 @@ class Prompter {
   static async selectGuideline() {
     const guidelineRoot = await Prompter.#getGuidelineRoot();
     const guideNames = (await fsPromise.readdir(guidelineRoot)).filter((name) => !name.startsWith("_"));
-    return await select3({ message: "Select a guideline", choices: guideNames.map((name) => ({ name, value: name })) });
+    return await select3({
+      message: "Select a guideline",
+      choices: guideNames.map((name) => ({ name, value: name }))
+    });
   }
   static async getGuideJson(guideName) {
     const guidelineRoot = await Prompter.#getGuidelineRoot();
@@ -9680,13 +9988,18 @@ class Prompter {
     return content;
   }
   static async getUpdateRequest(guideName) {
-    return await input3({ message: `What do you want to update in ${guideName}?` });
+    return await input3({
+      message: `What do you want to update in ${guideName}?`
+    });
   }
   async makeTsFileUpdatePrompt({ context, request }) {
     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.
 
+# Code Style
+- Use double quotes for all string literals in TypeScript/TSX code. Do not use single quotes.
+
 # Background Information
 \`\`\`markdown
 ${context}
@@ -9733,10 +10046,10 @@ import { useEffect as useEffect3, useState as useState3 } from "react";
 import { jsxDEV as jsxDEV2, Fragment as Fragment2 } from "react/jsx-dev-runtime";
 "use client";
 // pkgs/@akanjs/devkit/incrementalBuilder/incrementalBuilder.proc.ts
-import { Logger as Logger12 } from "akanjs/common";
+import { Logger as Logger11 } from "akanjs/common";
 
 class IncrementalBuilder {
-  #logger = new Logger12("IncrementalBuilder");
+  #logger = new Logger11("IncrementalBuilder");
   #app;
   #artifact;
   #watch;