@akanjs/devkit 2.3.9-rc.0 → 2.3.9-rc.10

package/capacitorApp.test.ts

@@ -130,16 +130,14 @@ describe("materializeCapacitorConfig", () => {
 describe("root capacitor config helpers", () => {
   test("clears root configs before writing the temporary json config", async () => {
     const root = await makeTempRoot();
-    await Promise.all(
-      rootCapacitorConfigFilenames.map((file) => writeFile(path.join(root, file), `old ${file}\n`)),
-    );
+    await Promise.all(rootCapacitorConfigFilenames.map((file) => writeFile(path.join(root, file), `old ${file}\n`)));
 
-    await writeRootCapacitorConfig(root, "{\n  \"appId\": \"com.minimal.app\"\n}\n");
+    await writeRootCapacitorConfig(root, '{\n  "appId": "com.minimal.app"\n}\n');
 
     expect(await Bun.file(path.join(root, "capacitor.config.ts")).exists()).toBe(false);
     expect(await Bun.file(path.join(root, "capacitor.config.js")).exists()).toBe(false);
     expect(await Bun.file(path.join(root, "capacitor.config.json")).text()).toBe(
-      "{\n  \"appId\": \"com.minimal.app\"\n}\n",
+      '{\n  "appId": "com.minimal.app"\n}\n',
     );
 
     await clearRootCapacitorConfigs(root);
@@ -186,7 +184,9 @@ describe("iOS native run helpers", () => {
           },
         }),
       ),
-    ).toEqual([{ id: "11111111-2222-3333-4444-555555555555", name: "iPhone 16", kind: "simulator", state: "Shutdown" }]);
+    ).toEqual([
+      { id: "11111111-2222-3333-4444-555555555555", name: "iPhone 16", kind: "simulator", state: "Shutdown" },
+    ]);
   });
 
   test("builds xcodebuild destinations and output paths by target kind", () => {
@@ -198,7 +198,9 @@ describe("iOS native run helpers", () => {
     });
     expect(deviceCommand.xcodebuildArgs).toContain("id=device-1");
     expect(deviceCommand.xcodebuildArgs).toContain("App QA");
-    expect(deviceCommand.appPath).toBe("/repo/apps/minimal/ios/DerivedData/device-1/Build/Products/Debug-iphoneos/App.app");
+    expect(deviceCommand.appPath).toBe(
+      "/repo/apps/minimal/ios/DerivedData/device-1/Build/Products/Debug-iphoneos/App.app",
+    );
 
     const simulatorCommand = buildIosNativeRunCommand({
       appRoot: "/repo/apps/minimal",
@@ -212,7 +214,11 @@ describe("iOS native run helpers", () => {
 
   test("classifies iOS signing and device-state failures", () => {
     expect(classifyIosRunFailure("There are no accounts registered with Xcode").kind).toBe("apple-account");
-    expect(classifyIosRunFailure('Failed Registering Bundle Identifier: The app identifier "com.minimal.app" cannot be registered to your development team').kind).toBe("bundle-identifier");
+    expect(
+      classifyIosRunFailure(
+        'Failed Registering Bundle Identifier: The app identifier "com.minimal.app" cannot be registered to your development team',
+      ).kind,
+    ).toBe("bundle-identifier");
     expect(classifyIosRunFailure("No profiles for 'com.minimal.app' were found").kind).toBe("provisioning-profile");
     expect(classifyIosRunFailure("Developer Mode is disabled on this device").kind).toBe("device-state");
     expect(classifyIosRunFailure("arm64-apple-darwin20.0: error: unknown argument: '-index-store-path'").kind).toBe(

package/commandDecorators/command.ts

@@ -165,7 +165,7 @@ const assertCurrentDirectoryIsWorkspaceRoot = async () => {
   );
 };
 
-const getInternalArgumentValue = async (
+export const getInternalArgumentValue = async (
   argMeta: InternalArgMeta,
   value: string | undefined,
   workspace: WorkspaceExecutor,
@@ -201,6 +201,7 @@ const getInternalArgumentValue = async (
     }
   } else if (sysType === "app") {
     if (value && appNames.includes(value)) return AppExecutor.from(workspace, value);
+    if (!value && appNames.length === 1 && appNames[0]) return AppExecutor.from(workspace, appNames[0]);
     const appName = await select<string>({ message: `Select the ${sysType} name`, choices: appNames });
     return AppExecutor.from(workspace, appName);
   } else if (sysType === "lib") {

package/commandDecorators/commandDecorators.test.ts

@@ -1,5 +1,7 @@
 import { afterEach, describe, expect, test } from "bun:test";
+import { AppExecutor, WorkspaceExecutor } from "../executors";
 import { App, getArgMetas, Lib, Module, Pkg, Sys, Workspace } from "./argMeta";
+import { getInternalArgumentValue } from "./command";
 import { command } from "./commandBuilder";
 import {
   assertUniqueDependencies,
@@ -127,6 +129,17 @@ describe("command helper metadata", () => {
     expect(commandHelp).toContain("[default: true]");
     expect(commandHelp).toContain("Fast, Full");
   });
+
+  test("resolves the only app without prompting for selection", async () => {
+    const workspace = new WorkspaceExecutor({ workspaceRoot: "/workspace", repoName: "repo" });
+    workspace.getExecs = async () => [["single-command-test-app"], [], []];
+
+    const app = await getInternalArgumentValue({ key: "", idx: 0, type: "App" }, undefined, workspace);
+
+    expect(app).toBeInstanceOf(AppExecutor);
+    expect(app.name).toBe("single-command-test-app");
+    expect(app.workspace).toBe(workspace);
+  });
 });
 
 describe("command helper dependency injection", () => {

package/devkitUtils.test.ts

@@ -269,11 +269,11 @@ describe("getModelFileData", () => {
         ].join("\n"),
       );
       await write(
-        path.join(root, "apps/demo/lib/post/post.Unit.tsx"),
+        path.join(root, "apps/demo/lib/post/Post.Unit.tsx"),
         "export default function Unit() { return null; }\n",
       );
       await write(
-        path.join(root, "apps/demo/lib/post/post.View.tsx"),
+        path.join(root, "apps/demo/lib/post/Post.View.tsx"),
         "export default function View() { return null; }\n",
       );
 

package/executors.test.ts

@@ -143,11 +143,32 @@ describe("Executor filesystem helpers", () => {
       "Akan.js Workspace Rules",
     );
     expect(await readFile(path.join(root, "workspace/AGENTS.md"), "utf8")).toContain("sample Agent Guide");
+    expect(await readFile(path.join(root, "workspace/docs/AI-DEVELOPMENT.md"), "utf8")).toContain(
+      "AI Development Guide",
+    );
+    expect(await readFile(path.join(root, "workspace/docs/GENERATED.md"), "utf8")).toContain("Generated Akan Files");
     expect(await readFile(path.join(root, "workspace/biome.json"), "utf8")).toContain(
       "./node_modules/@akanjs/devkit/lint/no-import-client-functions.grit",
     );
   });
 
+  test("applies app sample signal test helpers", async () => {
+    const root = await makeTempRoot();
+    const exec = new Executor("fixture", root);
+
+    await exec.applyTemplate({
+      basePath: "app",
+      template: "appSample",
+      dict: { appName: "demo" },
+      options: { libs: [] },
+    });
+
+    await expect(readFile(path.join(root, "app/lib/task/task.service.test.ts"), "utf8")).rejects.toThrow();
+    expect(await readFile(path.join(root, "app/lib/task/task.signal.spec.ts"), "utf8")).toContain("getCompletedTask");
+    expect(await readFile(path.join(root, "app/lib/task/task.signal.test.ts"), "utf8")).toContain("Task signal smoke");
+    expect(await readFile(path.join(root, "app/lib/task/task.document.ts"), "utf8")).toContain('action: "started"');
+  });
+
   test("copies static files from CLI templates", async () => {
     const root = await makeTempRoot();
     const exec = new Executor("fixture", root);

package/executors.ts

@@ -503,7 +503,7 @@ export class Executor {
   async writeFile(
     filePath: string,
     content: string | object,
-    { overwrite = true }: { overwrite?: boolean } = {},
+    { overwrite = true, silent = false }: { overwrite?: boolean; silent?: boolean } = {},
   ): Promise<FileContent> {
     const writePath = this.getPath(filePath);
     const dir = path.dirname(writePath);
@@ -521,7 +521,7 @@ export class Executor {
       }
     } else {
       await FileSys.writeText(writePath, contentStr);
-      this.logger.rawLog(chalk.green(`File Create: ${filePath}`));
+      if (!silent) this.logger.rawLog(chalk.green(`File Create: ${filePath}`));
     }
     return { filePath: writePath, content: contentStr };
   }
@@ -626,14 +626,14 @@ export class Executor {
       overwrite?: boolean;
     },
     dict: { [key: string]: string } = {},
-    options: { [key: string]: any } = {},
+    options: { [key: string]: unknown } = {},
   ): Promise<FileContent | null> {
     if (targetPath.endsWith(".ts") || targetPath.endsWith(".tsx")) {
       const getContent = (await import(templatePath)) as {
         default: (
           scanInfo: AppInfo | LibInfo | null,
           dict: { [key: string]: string },
-          options?: { [key: string]: any },
+          options?: { [key: string]: unknown },
         ) => Promise<string | null | { filename: string; content: string }>;
       };
       const result = await getContent.default(scanInfo ?? null, dict, options);
@@ -686,7 +686,7 @@ export class Executor {
     template: string;
     scanInfo?: AppInfo | LibInfo | null;
     dict?: { [key: string]: string };
-    options?: { [key: string]: any };
+    options?: { [key: string]: unknown };
     overwrite?: boolean;
   }): Promise<FileContent[]> {
     const templateRoot = await this.#resolveTemplateRoot();
@@ -752,7 +752,7 @@ export class Executor {
     basePath: string;
     template: string;
     dict?: { [key: string]: string };
-    options?: { [key: string]: any };
+    options?: { [key: string]: unknown };
     overwrite?: boolean;
   }): Promise<FileContent[]> {
     const dict = {
@@ -827,10 +827,10 @@ export class Executor {
     filePath: string,
     { fix = false, dryRun = false }: { fix?: boolean; dryRun?: boolean } = {},
   ): Promise<{
-    results: any[]; // ESLint.LintResult[];
+    results: unknown[]; // ESLint.LintResult[];
     message: string;
-    errors: any[]; // ESLintLinter.LintMessage[];
-    warnings: any[]; // ESLintLinter.LintMessage[];
+    errors: unknown[]; // ESLintLinter.LintMessage[];
+    warnings: unknown[]; // ESLintLinter.LintMessage[];
   }> {
     const path = this.getPath(filePath);
     const linter = this.getLinter();
@@ -1225,40 +1225,44 @@ export class SysExecutor extends Executor {
   async getViewComponents() {
     const viewComponents = (await this.readdir("lib"))
       .filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts"))
-      .filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${name}.View.tsx`).exists());
+      .filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${capitalize(name)}.View.tsx`).exists());
     return viewComponents;
   }
 
   async getUnitComponents() {
     const unitComponents = (await this.readdir("lib"))
       .filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts"))
-      .filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${name}.Unit.tsx`).exists());
+      .filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${capitalize(name)}.Unit.tsx`).exists());
     return unitComponents;
   }
   async getTemplateComponents() {
     const templateComponents = (await this.readdir("lib"))
       .filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts"))
-      .filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${name}.Template.tsx`).exists());
+      .filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${capitalize(name)}.Template.tsx`).exists());
     return templateComponents;
   }
 
   async getViewsSourceCode() {
     const viewComponents = await this.getViewComponents();
     return Promise.all(
-      viewComponents.map((viewComponent) => this.getLocalFile(`lib/${viewComponent}/${viewComponent}.View.tsx`)),
+      viewComponents.map((viewComponent) =>
+        this.getLocalFile(`lib/${viewComponent}/${capitalize(viewComponent)}.View.tsx`),
+      ),
     );
   }
   async getUnitsSourceCode() {
     const unitComponents = await this.getUnitComponents();
     return Promise.all(
-      unitComponents.map((unitComponent) => this.getLocalFile(`lib/${unitComponent}/${unitComponent}.Unit.tsx`)),
+      unitComponents.map((unitComponent) =>
+        this.getLocalFile(`lib/${unitComponent}/${capitalize(unitComponent)}.Unit.tsx`),
+      ),
     );
   }
   async getTemplatesSourceCode() {
     const templateComponents = await this.getTemplateComponents();
     return Promise.all(
       templateComponents.map((templateComponent) =>
-        this.getLocalFile(`lib/${templateComponent}/${templateComponent}.Template.tsx`),
+        this.getLocalFile(`lib/${templateComponent}/${capitalize(templateComponent)}.Template.tsx`),
       ),
     );
   }
@@ -1357,14 +1361,15 @@ export class AppExecutor extends SysExecutor {
   getCommandEnv(env: Record<string, string> = {}): Record<string, string> {
     const basePort = 8282;
     const portOffset = WorkspaceExecutor.getBaseDevEnv().portOffset;
-    const PORT = basePort ? (basePort + portOffset).toString() : undefined;
+    const PORT = (basePort + portOffset).toString();
     const AKAN_PUBLIC_SERVER_PORT = portOffset ? (8282 + portOffset).toString() : undefined;
     return {
       ...process.env,
       AKAN_PUBLIC_APP_NAME: this.name,
       AKAN_WORKSPACE_ROOT: this.workspace.workspaceRoot,
       NODE_NO_WARNINGS: "1",
-      ...(PORT ? { PORT, AKAN_PUBLIC_CLIENT_PORT: PORT } : {}),
+      PORT,
+      AKAN_PUBLIC_CLIENT_PORT: PORT,
       ...(AKAN_PUBLIC_SERVER_PORT ? { AKAN_PUBLIC_SERVER_PORT } : {}),
       ...env,
     };

package/getModelFileData.ts

@@ -1,3 +1,5 @@
+import { capitalize } from "akanjs/common";
+
 interface ModelFileData {
   moduleType: "lib" | "app";
   moduleName: string;
@@ -16,9 +18,10 @@ interface ModelFileData {
 export const getModelFileData = async (modulePath: string, modelName: string): Promise<ModelFileData> => {
   const moduleType = modulePath.startsWith("apps") ? "app" : "lib";
   const moduleName = modulePath.split("/")[1] ?? "";
+  const modelComponentName = capitalize(modelName);
   const constantFilePath = `${modulePath}/lib/${modelName}/${modelName}.constant.ts`;
-  const unitFilePath = `${modulePath}/lib/${modelName}/${modelName}.Unit.tsx`;
-  const viewFilePath = `${modulePath}/lib/${modelName}/${modelName}.View.tsx`;
+  const unitFilePath = `${modulePath}/lib/${modelName}/${modelComponentName}.Unit.tsx`;
+  const viewFilePath = `${modulePath}/lib/${modelName}/${modelComponentName}.View.tsx`;
   const [constantFileStr, unitFileStr, viewFileStr] = await Promise.all([
     Bun.file(constantFilePath).text(),
     Bun.file(unitFilePath).text(),

package/index.ts

@@ -2,6 +2,7 @@ export * from "./aiEditor";
 export * from "./akanApp";
 export * from "./akanConfig";
 export * from "./akanContext";
+export * from "./akanMcpContract";
 export * from "./applicationBuildReporter";
 export * from "./applicationBuildRunner";
 export * from "./applicationReleasePackager";
@@ -36,3 +37,4 @@ export * from "./types";
 export * from "./ui";
 export * from "./uploadRelease";
 export * from "./useStdoutDimensions";
+export * from "./workflow";

package/linter.ts

@@ -78,15 +78,12 @@ export class Linter {
 
   #toBiomePath(filePath: string): string {
     const relativePath = path.relative(this.lintRoot, filePath);
-    if (!relativePath.startsWith("..") && !path.isAbsolute(relativePath))
-      return relativePath;
+    if (!relativePath.startsWith("..") && !path.isAbsolute(relativePath)) return relativePath;
     return filePath;
   }
 
   #resolveFilePath(filePath: string): string {
-    return path.isAbsolute(filePath)
-      ? filePath
-      : path.join(this.lintRoot, filePath);
+    return path.isAbsolute(filePath) ? filePath : path.join(this.lintRoot, filePath);
   }
 
   async #runBiome(args: string[], input?: string) {
@@ -125,9 +122,7 @@ export class Linter {
   #diagnosticFilePath(diagnostic: BiomeDiagnostic, fallbackFilePath: string) {
     const diagnosticPath = diagnostic.location?.path;
     if (!diagnosticPath) return fallbackFilePath;
-    return path.isAbsolute(diagnosticPath)
-      ? diagnosticPath
-      : path.join(this.lintRoot, diagnosticPath);
+    return path.isAbsolute(diagnosticPath) ? diagnosticPath : path.join(this.lintRoot, diagnosticPath);
   }
 
   #createLintMessage(diagnostic: BiomeDiagnostic): LintMessage {
@@ -148,8 +143,7 @@ export class Linter {
     const resultsByPath = new Map<string, LintResult>();
 
     for (const diagnostic of report.diagnostics ?? []) {
-      if (diagnostic.severity !== "error" && diagnostic.severity !== "warning")
-        continue;
+      if (diagnostic.severity !== "error" && diagnostic.severity !== "warning") continue;
       const diagnosticFilePath = this.#diagnosticFilePath(diagnostic, filePath);
       const result =
         resultsByPath.get(diagnosticFilePath) ??
@@ -178,9 +172,7 @@ export class Linter {
           fixableErrorCount: 0,
           fixableWarningCount: 0,
         } satisfies LintResult),
-      ...[...resultsByPath.entries()]
-        .filter(([resultPath]) => resultPath !== filePath)
-        .map(([, result]) => result),
+      ...[...resultsByPath.entries()].filter(([resultPath]) => resultPath !== filePath).map(([, result]) => result),
     ];
   }
 
@@ -192,13 +184,8 @@ export class Linter {
     };
   }
 
-  async #checkFile(
-    filePath: string,
-    { write = false }: { write?: boolean } = {},
-  ): Promise<LintResponse> {
-    const originalContent = existsSync(filePath)
-      ? readFileSync(filePath, "utf8")
-      : "";
+  async #checkFile(filePath: string, { write = false }: { write?: boolean } = {}): Promise<LintResponse> {
+    const originalContent = existsSync(filePath) ? readFileSync(filePath, "utf8") : "";
     const { stdout, stderr } = await this.#runBiome([
       "check",
       ...(write ? ["--write"] : []),
@@ -212,10 +199,7 @@ export class Linter {
     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;
+    const output = write && existsSync(filePath) ? readFileSync(filePath, "utf8") : undefined;
 
     return {
       fixed: write && output !== originalContent,
@@ -226,10 +210,7 @@ export class Linter {
     };
   }
 
-  async lint(
-    filePath: string,
-    { fix = false, dryRun = false }: { fix?: boolean; dryRun?: boolean } = {},
-  ) {
+  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);
   }
@@ -241,8 +222,7 @@ export class Linter {
    */
   async lintFile(filePath: string): Promise<LintResponse> {
     const resolvedFilePath = this.#resolveFilePath(filePath);
-    if (!existsSync(resolvedFilePath))
-      throw new Error(`File not found: ${filePath}`);
+    if (!existsSync(resolvedFilePath)) throw new Error(`File not found: ${filePath}`);
     return await this.#checkFile(resolvedFilePath);
   }
 
@@ -279,16 +259,10 @@ export class Linter {
           const type = message.severity === 2 ? "error" : "warning";
           const typeColor = message.severity === 2 ? chalk.red : chalk.yellow;
           const icon = message.severity === 2 ? "x" : "!";
-          const ruleInfo = message.ruleId
-            ? chalk.dim(` (${message.ruleId})`)
-            : "";
+          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}`)}`,
-          );
+          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) {
@@ -299,28 +273,19 @@ export class Linter {
 
             // Create underline
             const underlinePrefix = " ".repeat(message.column - 1);
-            const underlineLength = message.endColumn
-              ? message.endColumn - 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)}`,
-            );
+            output.push(`${chalk.dim(`${" ".repeat(lineNumber.length)} |`)} ${underlinePrefix}${typeColor(underline)}`);
           }
         });
       }
     });
 
-    if (totalErrors === 0 && totalWarnings === 0)
-      return chalk.bold("No Biome errors or warnings found");
+    if (totalErrors === 0 && totalWarnings === 0) return chalk.bold("No Biome 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 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");
@@ -355,8 +320,7 @@ export class Linter {
         column: message.column,
         message: message.message,
         ruleId: message.ruleId,
-        severity:
-          message.severity === 2 ? ("error" as const) : ("warning" as const),
+        severity: message.severity === 2 ? ("error" as const) : ("warning" as const),
       })),
     );
 
@@ -365,8 +329,7 @@ export class Linter {
         errorCount: acc.errorCount + result.errorCount,
         warningCount: acc.warningCount + result.warningCount,
         fixableErrorCount: acc.fixableErrorCount + result.fixableErrorCount,
-        fixableWarningCount:
-          acc.fixableWarningCount + result.fixableWarningCount,
+        fixableWarningCount: acc.fixableWarningCount + result.fixableWarningCount,
       }),
       {
         errorCount: 0,
@@ -400,9 +363,7 @@ export class Linter {
    */
   async getErrors(filePath: string): Promise<LintMessage[]> {
     const { results } = await this.lintFile(filePath);
-    return results.flatMap((result) =>
-      result.messages.filter((message) => message.severity === 2),
-    );
+    return results.flatMap((result) => result.messages.filter((message) => message.severity === 2));
   }
 
   /**
@@ -412,9 +373,7 @@ export class Linter {
    */
   async getWarnings(filePath: string): Promise<LintMessage[]> {
     const { results } = await this.lintFile(filePath);
-    return results.flatMap((result) =>
-      result.messages.filter((message) => message.severity === 1),
-    );
+    return results.flatMap((result) => result.messages.filter((message) => message.severity === 1));
   }
 
   /**
@@ -425,11 +384,9 @@ export class Linter {
    */
   async fixFile(filePath: string, dryRun = false): Promise<LintResponse> {
     const resolvedFilePath = this.#resolveFilePath(filePath);
-    if (!existsSync(resolvedFilePath))
-      throw new Error(`File not found: ${filePath}`);
+    if (!existsSync(resolvedFilePath)) throw new Error(`File not found: ${filePath}`);
 
-    if (!dryRun)
-      return await this.#checkFile(resolvedFilePath, { write: true });
+    if (!dryRun) return await this.#checkFile(resolvedFilePath, { write: true });
 
     const source = readFileSync(resolvedFilePath, "utf8");
     const { stdout } = await this.#runBiome(
@@ -454,11 +411,8 @@ export class Linter {
    */
   async getConfigForFile(filePath: string): Promise<unknown> {
     const resolvedFilePath = this.#resolveFilePath(filePath);
-    if (!existsSync(resolvedFilePath))
-      throw new Error(`File not found: ${filePath}`);
-    return JSON.parse(
-      readFileSync(path.join(this.lintRoot, "biome.json"), "utf8"),
-    ) as unknown;
+    if (!existsSync(resolvedFilePath)) throw new Error(`File not found: ${filePath}`);
+    return JSON.parse(readFileSync(path.join(this.lintRoot, "biome.json"), "utf8")) as unknown;
   }
 
   /**
@@ -472,8 +426,7 @@ export class Linter {
 
     results.forEach((result) => {
       result.messages.forEach((message) => {
-        if (message.ruleId)
-          ruleCounts[message.ruleId] = (ruleCounts[message.ruleId] || 0) + 1;
+        if (message.ruleId) ruleCounts[message.ruleId] = (ruleCounts[message.ruleId] || 0) + 1;
       });
     });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "2.3.9-rc.0",
+  "version": "2.3.9-rc.10",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -32,7 +32,7 @@
     "@langchain/openai": "^1.4.6",
     "@tailwindcss/node": "^4.3.0",
     "@trapezedev/project": "^7.1.4",
-    "akanjs": "2.3.9-rc.0",
+    "akanjs": "2.3.9-rc.10",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "daisyui": "5.5.23",

package/typecheck/typecheck.proc.ts

@@ -8,8 +8,7 @@ try {
     if (!cwdPath) throw new Error("AKAN_TYPECHECK_CWD is required");
 
     const typeChecker = new TypeChecker({ cwdPath } as never);
-    const { fileDiagnostics, fileErrors, fileWarnings } =
-      typeChecker.check(filePath);
+    const { fileDiagnostics, fileErrors, fileWarnings } = typeChecker.check(filePath);
     const message = typeChecker.formatDiagnostics(fileDiagnostics);
     Logger.rawLog(
       JSON.stringify({