@akanjs/cli 2.1.0-rc.0 → 2.1.0-rc.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/cli",
-  "version": "2.1.0-rc.0",
+  "version": "2.1.0-rc.10",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -34,9 +34,10 @@
     "@langchain/deepseek": "^1.0.26",
     "@langchain/openai": "^1.4.6",
     "@trapezedev/project": "^7.1.4",
-    "akanjs": "2.1.0-rc.0",
+    "akanjs": "2.1.0-rc.9",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
+    "daisyui": "^5.5.20",
     "fontaine": "^0.8.0",
     "fonteditor-core": "^2.6.3",
     "ignore": "^7.0.5",
@@ -47,6 +48,7 @@
     "react": "19.2.6",
     "ssh2": "^1.17.0",
     "subset-font": "^2.5.0",
+    "tailwind-scrollbar": "^4.0.2",
     "tailwindcss": "^4.3.0",
     "typescript": "^6.0.3"
   },

package/templates/facetIndex/index.ts

@@ -1,5 +1,5 @@
-import type { AppInfo, LibInfo } from "akanjs";
 import type { SysExecutor } from "@akanjs/devkit";
+import type { AppInfo, LibInfo } from "akanjs";
 
 interface Dict {
   [key: string]: string;

package/templates/workspaceRoot/.gitignore.template

@@ -117,4 +117,5 @@ libs/*/common/index.ts
 libs/*/client.ts
 libs/*/server.ts
 libs/*/index.ts
-**/.akan
+**/.akan
+**/bun.lock

package/typecheck.proc.js

@@ -0,0 +1,208 @@
+// @bun
+var __require = import.meta.require;
+
+// pkgs/@akanjs/devkit/typeChecker.ts
+import { readFileSync } from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import * as ts from "typescript";
+
+class TypeChecker {
+  configPath;
+  configFile;
+  config;
+  constructor(executor) {
+    const configPath = this.#findConfigFile(executor.cwdPath);
+    if (!configPath)
+      throw new Error("No tsconfig.json found in the project");
+    this.configPath = configPath;
+    this.configFile = ts.readConfigFile(this.configPath, (fileName) => ts.sys.readFile(fileName));
+    const parsedConfig = ts.parseJsonConfigFileContent(this.configFile.config, ts.sys, path.dirname(this.configPath), undefined, this.configPath);
+    if (parsedConfig.errors.length > 0) {
+      const errorMessages = parsedConfig.errors.map((error) => ts.flattenDiagnosticMessageText(error.messageText, `
+`)).join(`
+`);
+      throw new Error(`Error parsing tsconfig.json:
+${errorMessages}`);
+    }
+    this.config = parsedConfig;
+  }
+  #findConfigFile(searchPath) {
+    return ts.findConfigFile(searchPath, (fileName) => ts.sys.fileExists(fileName), "tsconfig.json");
+  }
+  check(filePath) {
+    const program = ts.createProgram([filePath], this.config.options);
+    const diagnostics = [
+      ...program.getSemanticDiagnostics(),
+      ...program.getSyntacticDiagnostics(),
+      ...this.config.options.declaration ? program.getDeclarationDiagnostics() : []
+    ];
+    const errors = diagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
+    const warnings = diagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Warning);
+    const fileDiagnostics = diagnostics.filter((diagnostic) => diagnostic.file?.fileName === filePath);
+    const fileErrors = fileDiagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
+    const fileWarnings = fileDiagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Warning);
+    return { diagnostics, errors, warnings, fileDiagnostics, fileErrors, fileWarnings };
+  }
+  formatDiagnostics(diagnostics) {
+    if (diagnostics.length === 0)
+      return chalk.bold("\u2705 No type errors found");
+    const output = [];
+    let errorCount = 0;
+    let warningCount = 0;
+    let suggestionCount = 0;
+    const diagnosticsByFile = new Map;
+    diagnostics.forEach((diagnostic) => {
+      if (diagnostic.category === ts.DiagnosticCategory.Error)
+        errorCount++;
+      else if (diagnostic.category === ts.DiagnosticCategory.Warning)
+        warningCount++;
+      else if (diagnostic.category === ts.DiagnosticCategory.Suggestion)
+        suggestionCount++;
+      if (diagnostic.file) {
+        const fileName = diagnostic.file.fileName;
+        if (!diagnosticsByFile.has(fileName))
+          diagnosticsByFile.set(fileName, []);
+        const fileDiagnostics = diagnosticsByFile.get(fileName);
+        if (fileDiagnostics)
+          fileDiagnostics.push(diagnostic);
+      } else {
+        if (!diagnosticsByFile.has(""))
+          diagnosticsByFile.set("", []);
+        const fileDiagnostics = diagnosticsByFile.get("");
+        if (fileDiagnostics)
+          fileDiagnostics.push(diagnostic);
+      }
+    });
+    diagnosticsByFile.forEach((fileDiagnostics, fileName) => {
+      if (fileName)
+        output.push(`
+${chalk.cyan(fileName)}`);
+      fileDiagnostics.forEach((diagnostic) => {
+        const categoryText = diagnostic.category === ts.DiagnosticCategory.Error ? "error" : diagnostic.category === ts.DiagnosticCategory.Warning ? "warning" : "suggestion";
+        const categoryColor = diagnostic.category === ts.DiagnosticCategory.Error ? chalk.red : diagnostic.category === ts.DiagnosticCategory.Warning ? chalk.yellow : chalk.blue;
+        const icon = diagnostic.category === ts.DiagnosticCategory.Error ? "\u274C" : diagnostic.category === ts.DiagnosticCategory.Warning ? "\u26A0\uFE0F" : "\uD83D\uDCA1";
+        const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, `
+`);
+        const tsCode = chalk.dim(`(TS${diagnostic.code})`);
+        if (diagnostic.file && diagnostic.start !== undefined) {
+          const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+          output.push(`
+  ${icon} ${categoryColor(categoryText)}: ${message} ${tsCode}`);
+          output.push(`     ${chalk.gray("at")} ${fileName}:${chalk.bold(`${line + 1}:${character + 1}`)}`);
+          const sourceLines = diagnostic.file.text.split(`
+`);
+          if (line < sourceLines.length) {
+            const sourceLine = sourceLines[line];
+            const lineNumber = (line + 1).toString().padStart(5, " ");
+            output.push(`
+${chalk.dim(`${lineNumber} |`)} ${sourceLine}`);
+            const underlinePrefix = " ".repeat(character);
+            const length = diagnostic.length ?? 1;
+            const underline = "~".repeat(Math.max(1, length));
+            output.push(`${chalk.dim(`${" ".repeat(lineNumber.length)} |`)} ${underlinePrefix}${categoryColor(underline)}`);
+          }
+        } else
+          output.push(`
+  ${icon} ${categoryColor(categoryText)}: ${message} ${tsCode}`);
+      });
+    });
+    const summary = [];
+    if (errorCount > 0)
+      summary.push(chalk.red(`${errorCount} error(s)`));
+    if (warningCount > 0)
+      summary.push(chalk.yellow(`${warningCount} warning(s)`));
+    if (suggestionCount > 0)
+      summary.push(chalk.blue(`${suggestionCount} suggestion(s)`));
+    return `
+${summary.join(", ")} found${output.join(`
+`)}`;
+  }
+  getDetailedDiagnostics(filePath) {
+    const { diagnostics } = this.check(filePath);
+    const sourceFile = ts.createSourceFile(filePath, readFileSync(filePath, "utf8"), ts.ScriptTarget.Latest, true);
+    const details = diagnostics.map((diagnostic) => {
+      if (diagnostic.file && diagnostic.start !== undefined) {
+        const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+        const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, `
+`);
+        const lines = sourceFile.text.split(`
+`);
+        const codeSnippet = line < lines.length ? lines[line] : undefined;
+        return { line: line + 1, column: character + 1, message, code: diagnostic.code, codeSnippet };
+      }
+      return {
+        line: 0,
+        column: 0,
+        message: ts.flattenDiagnosticMessageText(diagnostic.messageText, `
+`),
+        code: diagnostic.code
+      };
+    });
+    return { diagnostics, details };
+  }
+  hasNoTypeErrors(filePath) {
+    try {
+      const { diagnostics } = this.check(filePath);
+      return diagnostics.length === 0;
+    } catch (error) {
+      return false;
+    }
+  }
+  static checkProject(configPath) {
+    const parsedConfig = TypeChecker.parseConfig(configPath);
+    const host = ts.createIncrementalCompilerHost(parsedConfig.options);
+    const builderProgram = ts.createIncrementalProgram({
+      rootNames: parsedConfig.fileNames,
+      options: parsedConfig.options,
+      projectReferences: parsedConfig.projectReferences,
+      configFileParsingDiagnostics: parsedConfig.errors,
+      host
+    });
+    const program = builderProgram.getProgram();
+    const diagnostics = [...ts.getPreEmitDiagnostics(program), ...builderProgram.emit().diagnostics];
+    const errors = diagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
+    const warnings = diagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Warning);
+    return {
+      configPath,
+      diagnostics,
+      errors,
+      warnings,
+      message: TypeChecker.formatDiagnosticMessages(diagnostics)
+    };
+  }
+  static parseConfig(configPath) {
+    const configFile = ts.readConfigFile(configPath, (fileName) => ts.sys.readFile(fileName));
+    const configDiagnostics = configFile.error ? [configFile.error] : [];
+    if (!configFile.config) {
+      const message = TypeChecker.formatDiagnosticMessages(configDiagnostics);
+      throw new Error(message || `Error reading tsconfig.json: ${configPath}`);
+    }
+    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath), undefined, configPath);
+    if (parsedConfig.errors.length > 0)
+      throw new Error(TypeChecker.formatDiagnosticMessages(parsedConfig.errors));
+    return parsedConfig;
+  }
+  static formatDiagnosticMessages(diagnostics) {
+    return ts.formatDiagnosticsWithColorAndContext(diagnostics, {
+      getCanonicalFileName: (fileName) => fileName,
+      getCurrentDirectory: () => process.cwd(),
+      getNewLine: () => ts.sys.newLine
+    });
+  }
+}
+
+// pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts
+try {
+  const configPath = process.env.AKAN_TYPECHECK_TSCONFIG;
+  if (!configPath)
+    throw new Error("AKAN_TYPECHECK_TSCONFIG is required");
+  const result = TypeChecker.checkProject(configPath);
+  if (result.errors.length > 0) {
+    console.error(result.message);
+    process.exit(1);
+  }
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+}