@akanjs/devkit 2.1.1-rc.1 → 2.1.1

package/index.ts

@@ -6,11 +6,11 @@ export * from "./applicationBuildRunner";
 export * from "./applicationReleasePackager";
 export * from "./applicationTestPreload";
 export * from "./artifact";
-export * from "./auth";
 export * from "./builder";
 export * from "./capacitorApp";
+export * from "./cloud";
+export * from "./cloud";
 export * from "./commandDecorators";
-export * from "./constants";
 export * from "./createTunnel";
 export * from "./dependencyScanner";
 export * from "./executors";
@@ -35,4 +35,3 @@ export * from "./types";
 export * from "./ui";
 export * from "./uploadRelease";
 export * from "./useStdoutDimensions";
-export * from "./cloud";

package/linter.ts

@@ -1,60 +1,257 @@
+import { spawn } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
-import * as path from "node:path";
-import { Logger } from "akanjs/common";
+import path from "node:path";
 import chalk from "chalk";
-// import { ESLint, type Linter as ESLintLinter } from "eslint";
+
+type BiomeSeverity = "error" | "warning" | "information" | "hint";
+
+interface BiomePosition {
+  line: number;
+  column: number;
+}
+
+interface BiomeDiagnostic {
+  severity: BiomeSeverity;
+  message: string;
+  category?: string;
+  location?: {
+    path?: string;
+    start?: BiomePosition;
+    end?: BiomePosition;
+  };
+}
+
+interface BiomeReport {
+  summary?: {
+    changed?: number;
+    errors?: number;
+    warnings?: number;
+    infos?: number;
+  };
+  diagnostics?: BiomeDiagnostic[];
+}
+
+interface LintMessage {
+  line: number;
+  column: number;
+  endLine?: number;
+  endColumn?: number;
+  message: string;
+  ruleId: string | null;
+  severity: 1 | 2;
+}
+
+interface LintResult {
+  filePath: string;
+  messages: LintMessage[];
+  errorCount: number;
+  warningCount: number;
+  fixableErrorCount: number;
+  fixableWarningCount: number;
+}
+
+interface LintResponse {
+  fixed: boolean;
+  output?: string;
+  results: LintResult[];
+  errors: LintMessage[];
+  warnings: LintMessage[];
+}
 
 export class Linter {
-  #logger = new Logger("Linter");
-  // #eslint: any;
   lintRoot: string;
+  #biomeBin: string;
 
   constructor(cwdPath: string) {
-    this.lintRoot = this.#findEslintRootPath(cwdPath);
-    // this.#eslint = new ESLint({ cwd: this.lintRoot, errorOnUnmatchedPattern: false });
+    this.lintRoot = this.#findBiomeRootPath(cwdPath);
+    const localBiomeBin = path.join(this.lintRoot, "node_modules/.bin/biome");
+    this.#biomeBin = existsSync(localBiomeBin) ? localBiomeBin : "biome";
   }
-  #findEslintRootPath(dir: string): string {
-    const configPath = path.join(dir, "eslint.config.ts");
+
+  #findBiomeRootPath(dir: string): string {
+    const configPath = path.join(dir, "biome.json");
     if (existsSync(configPath)) return dir;
     const parentDir = path.dirname(dir);
-    return this.#findEslintRootPath(parentDir);
+    if (parentDir === dir) throw new Error(`biome.json not found from ${dir}`);
+    return this.#findBiomeRootPath(parentDir);
+  }
+
+  #toBiomePath(filePath: string): string {
+    const relativePath = path.relative(this.lintRoot, filePath);
+    if (!relativePath.startsWith("..") && !path.isAbsolute(relativePath))
+      return relativePath;
+    return filePath;
+  }
+
+  #resolveFilePath(filePath: string): string {
+    return path.isAbsolute(filePath)
+      ? filePath
+      : path.join(this.lintRoot, filePath);
+  }
+
+  async #runBiome(args: string[], input?: string) {
+    return await new Promise<{
+      stdout: string;
+      stderr: string;
+      code: number | null;
+    }>((resolve, reject) => {
+      const proc = spawn(this.#biomeBin, args, {
+        cwd: this.lintRoot,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+      let stdout = "";
+      let stderr = "";
+
+      proc.stdout.on("data", (data: Buffer) => {
+        stdout += data.toString();
+      });
+      proc.stderr.on("data", (data: Buffer) => {
+        stderr += data.toString();
+      });
+      proc.on("error", reject);
+      proc.on("close", (code) => resolve({ stdout, stderr, code }));
+      proc.stdin.end(input);
+    });
+  }
+
+  #parseBiomeReport(output: string): BiomeReport {
+    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)) as BiomeReport;
   }
-  async lint(filePath: string, { fix = false, dryRun = false }: { fix?: boolean; dryRun?: boolean } = {}) {
+
+  #diagnosticFilePath(diagnostic: BiomeDiagnostic, fallbackFilePath: string) {
+    const diagnosticPath = diagnostic.location?.path;
+    if (!diagnosticPath) return fallbackFilePath;
+    return path.isAbsolute(diagnosticPath)
+      ? diagnosticPath
+      : path.join(this.lintRoot, diagnosticPath);
+  }
+
+  #createLintMessage(diagnostic: BiomeDiagnostic): LintMessage {
+    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: BiomeReport, filePath: string): LintResult[] {
+    const resultsByPath = new Map<string, LintResult>();
+
+    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,
+        } satisfies LintResult);
+      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,
+        } satisfies LintResult),
+      ...[...resultsByPath.entries()]
+        .filter(([resultPath]) => resultPath !== filePath)
+        .map(([, result]) => result),
+    ];
+  }
+
+  #splitMessages(results: LintResult[]) {
+    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: string,
+    { write = false }: { write?: boolean } = {},
+  ): Promise<LintResponse> {
+    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",
+      path.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: 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
+   * Lint a single file using Biome.
    * @param filePath - Path to the file to lint
-   * @returns Array of ESLint results
+   * @returns Array of Biome results in the legacy lint result shape
    */
-  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: [] };
+  async lintFile(filePath: string): Promise<LintResponse> {
+    const resolvedFilePath = this.#resolveFilePath(filePath);
+    if (!existsSync(resolvedFilePath))
+      throw new Error(`File not found: ${filePath}`);
+    return await this.#checkFile(resolvedFilePath);
   }
 
   /**
    * Format lint results for console output
-   * @param results - Array of ESLint results
+   * @param results - Array of Biome results
    * @returns Formatted string
    */
-  formatLintResults(results: any[]): string {
-    // ESLint.LintResult[]
+  formatLintResults(results: LintResult[]): string {
     if (results.length === 0) return "No files to lint";
 
     const output: string[] = [];
@@ -68,25 +265,30 @@ export class Linter {
       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) {
+          } catch {
             // Ignore read errors
           }
         }
 
-        result.messages.forEach((message: any) => {
+        result.messages.forEach((message) => {
           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})`) : "";
+          const icon = message.severity === 2 ? "x" : "!";
+          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) {
@@ -97,19 +299,28 @@ 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 ESLint 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");
@@ -121,24 +332,13 @@ export class Linter {
    * @returns Object containing detailed lint information
    */
   async getDetailedLintInfo(filePath: string): Promise<{
-    results: any[]; // ESLint.LintResult[];
+    results: 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;
@@ -150,14 +350,13 @@ export class Linter {
     const { results } = await this.lintFile(filePath);
 
     const details = results.flatMap((result) =>
-      result.messages.map((message: any) => ({
+      result.messages.map((message) => ({
         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,
+        severity:
+          message.severity === 2 ? ("error" as const) : ("warning" as const),
       })),
     );
 
@@ -166,9 +365,15 @@ 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, warningCount: 0, fixableErrorCount: 0, fixableWarningCount: 0 },
+      {
+        errorCount: 0,
+        warningCount: 0,
+        fixableErrorCount: 0,
+        fixableWarningCount: 0,
+      },
     );
 
     return { results, details, stats };
@@ -183,7 +388,7 @@ export class Linter {
     try {
       const { results } = await this.lintFile(filePath);
       return results.every((result) => result.errorCount === 0);
-    } catch (error) {
+    } catch {
       return false;
     }
   }
@@ -193,10 +398,11 @@ export class Linter {
    * @param filePath - Path to the file to lint
    * @returns Array of error messages
    */
-  async getErrors(filePath: string): Promise<any[]> {
-    // ESLintLinter.LintMessage[]
+  async getErrors(filePath: string): Promise<LintMessage[]> {
     const { results } = await this.lintFile(filePath);
-    return results.flatMap((result) => result.messages.filter((message: any) => message.severity === 2));
+    return results.flatMap((result) =>
+      result.messages.filter((message) => message.severity === 2),
+    );
   }
 
   /**
@@ -204,10 +410,11 @@ export class Linter {
    * @param filePath - Path to the file to lint
    * @returns Array of warning messages
    */
-  async getWarnings(filePath: string): Promise<any[]> {
-    // ESLintLinter.LintMessage[]
+  async getWarnings(filePath: string): Promise<LintMessage[]> {
     const { results } = await this.lintFile(filePath);
-    return results.flatMap((result) => result.messages.filter((message: any) => message.severity === 1));
+    return results.flatMap((result) =>
+      result.messages.filter((message) => message.severity === 1),
+    );
   }
 
   /**
@@ -216,39 +423,42 @@ export class Linter {
    * @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}`);
+  async fixFile(filePath: string, dryRun = false): Promise<LintResponse> {
+    const resolvedFilePath = this.#resolveFilePath(filePath);
+    if (!existsSync(resolvedFilePath))
+      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);
+    if (!dryRun)
+      return await this.#checkFile(resolvedFilePath, { write: true });
 
-    // const fixedResult = results[0];
-    // return { fixed: fixedResult.output !== undefined, output: fixedResult.output, results, errors, warnings };
-    return { fixed: false, output: undefined, results: [], errors: [], warnings: [] };
+    const source = readFileSync(resolvedFilePath, "utf8");
+    const { stdout } = await this.#runBiome(
+      [
+        "check",
+        "--write",
+        "--config-path",
+        path.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 };
   }
 
   /**
-   * Get ESLint configuration for a file
+   * Get Biome configuration for a file
    * @param filePath - Path to the file
-   * @returns ESLint configuration object
+   * @returns Biome configuration object
    */
   async getConfigForFile(filePath: string): Promise<unknown> {
-    // const eslint = new ESLint();
-    // const config = (await eslint.calculateConfigForFile(filePath)) as unknown;
-    // return config;
-    return {};
+    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;
   }
 
   /**
@@ -261,8 +471,9 @@ export class Linter {
     const ruleCounts: Record<string, number> = {};
 
     results.forEach((result) => {
-      result.messages.forEach((message: any) => {
-        if (message.ruleId) ruleCounts[message.ruleId] = (ruleCounts[message.ruleId] || 0) + 1;
+      result.messages.forEach((message) => {
+        if (message.ruleId)
+          ruleCounts[message.ruleId] = (ruleCounts[message.ruleId] || 0) + 1;
       });
     });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "2.1.1-rc.1",
+  "version": "2.1.1",
   "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.1.1-rc.1",
+    "akanjs": "2.1.1",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "daisyui": "^5.5.20",

package/prompter.ts

@@ -11,7 +11,10 @@ interface FileUpdateRequestProps {
 export class Prompter {
   static async #getGuidelineRoot() {
     const dirname = getDirname(import.meta.url);
-    const candidates = [`${dirname}/guidelines`, `${dirname}/../cli/guidelines`];
+    const candidates = [
+      `${dirname}/guidelines`,
+      `${dirname}/../cli/guidelines`,
+    ];
     for (const candidate of candidates) {
       try {
         await fsPromise.access(candidate);
@@ -25,8 +28,13 @@ export class Prompter {
 
   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 })) });
+    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();
@@ -41,7 +49,9 @@ export class Prompter {
     return content;
   }
   static async getUpdateRequest(guideName: string) {
-    return await input({ message: `What do you want to update in ${guideName}?` });
+    return await input({
+      message: `What do you want to update in ${guideName}?`,
+    });
   }
 
   async makeTsFileUpdatePrompt({ context, request }: FileUpdateRequestProps) {
@@ -49,6 +59,9 @@ export class Prompter {
 ${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}

package/typecheck/typecheck.proc.ts

@@ -1,6 +1,27 @@
+import { Logger } from "akanjs/common";
 import { TypeChecker } from "../typeChecker";
 
 try {
+  const filePath = process.env.AKAN_TYPECHECK_FILE;
+  if (filePath) {
+    const cwdPath = process.env.AKAN_TYPECHECK_CWD;
+    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 message = typeChecker.formatDiagnostics(fileDiagnostics);
+    Logger.rawLog(
+      JSON.stringify({
+        fileDiagnosticsCount: fileDiagnostics.length,
+        fileErrorsCount: fileErrors.length,
+        fileWarningsCount: fileWarnings.length,
+        message,
+      }),
+    );
+    process.exit(0);
+  }
+
   const configPath = process.env.AKAN_TYPECHECK_TSCONFIG;
   if (!configPath) throw new Error("AKAN_TYPECHECK_TSCONFIG is required");
   const result = TypeChecker.checkProject(configPath);