@akanjs/cli 2.4.0 → 2.4.1-rc.0

package/index-wnp7hwq7.js

@@ -0,0 +1,193 @@
+// @bun
+// 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
+    });
+  }
+}
+
+export { TypeChecker };

package/index-wq8jwx8z.js

@@ -0,0 +1,224 @@
+// @bun
+import {
+  runner,
+  script
+} from "./index-hdqztm58.js";
+import {
+  PkgExecutor
+} from "./index-a6sbyy0b.js";
+import {
+  TypeScriptDependencyScanner
+} from "./index-x53a5nya.js";
+import {
+  FileSys
+} from "./index-61keag0s.js";
+
+// pkgs/@akanjs/cli/package/package.runner.ts
+import path from "path";
+import { Logger } from "akanjs/common";
+var {$ } = globalThis.Bun;
+
+class PackageRunner extends runner("package") {
+  static publishableAkanPackages = [
+    "akanjs",
+    "@akanjs/cli",
+    "@akanjs/devkit",
+    "create-akan-workspace"
+  ];
+  async version(workspace, { log = true } = {}) {
+    const pkgJson = process.env.USE_AKANJS_PKGS === "true" ? await FileSys.readJson(`${workspace?.workspaceRoot ?? process.cwd()}/pkgs/akanjs/package.json`) : await this.#getInstalledPackageJson();
+    const version = pkgJson.name === "akanjs" ? pkgJson.version : pkgJson.dependencies?.akanjs ?? pkgJson.version;
+    if (log)
+      Logger.rawLog(`akanjs@${version}`);
+    return version;
+  }
+  async#getInstalledPackageJson() {
+    const packageJsonCandidates = [
+      `${path.dirname(Bun.main)}/package.json`,
+      `${process.cwd()}/node_modules/akanjs/package.json`
+    ];
+    try {
+      packageJsonCandidates.unshift(Bun.resolveSync("akanjs/package.json", path.dirname(Bun.main)));
+    } catch {}
+    for (const packageJsonPath of packageJsonCandidates) {
+      if (!await Bun.file(packageJsonPath).exists())
+        continue;
+      const packageJson = await FileSys.readJson(packageJsonPath);
+      if (packageJson.name === "akanjs" || packageJson.name === "@akanjs/cli")
+        return packageJson;
+    }
+    throw new Error(`[package] failed to locate akanjs package.json from ${path.dirname(Bun.main)}`);
+  }
+  async createPackage(workspace, pkgName) {
+    await workspace.applyTemplate({ basePath: `pkgs/${pkgName}`, template: "pkgRoot", dict: { pkgName } });
+    await workspace.setPkgTsPaths(pkgName);
+  }
+  async removePackage(pkg) {
+    await pkg.workspace.exec(`rm -rf pkgs/${pkg.name}`);
+    await pkg.workspace.unsetPkgTsPaths(pkg.name);
+  }
+  async scanSync(pkg) {
+    const scanResult = await pkg.scan();
+    return scanResult;
+  }
+  async buildPackage(pkg) {
+    await $`rm -rf ${pkg.dist.cwdPath}`;
+    await pkg.dist.mkdir(pkg.dist.cwdPath);
+    const scanner = await TypeScriptDependencyScanner.from(pkg);
+    const { npmDeps, npmDevDeps, missingDeps } = await scanner.getPackageBuildDependencies(pkg.name);
+    const packageRuntimeDependencies = {
+      "@akanjs/devkit": ["daisyui", "tailwind-scrollbar"]
+    };
+    const packageRuntimeDevDependencies = { akanjs: ["@biomejs/biome", "@types/bun"] };
+    if (pkg.name === "@akanjs/cli") {
+      const devkitPackageJson = await pkg.workspace.readJson("pkgs/@akanjs/devkit/package.json");
+      packageRuntimeDependencies[pkg.name] = [
+        ...Object.keys(devkitPackageJson.dependencies ?? {}),
+        "daisyui",
+        "tailwind-scrollbar"
+      ].filter((dep) => dep !== "akanjs" && dep !== "@akanjs/devkit");
+    }
+    const bundledRuntimeDeps = new Set(pkg.name === "@akanjs/cli" ? ["@akanjs/devkit"] : []);
+    const forcedRuntimeDeps = packageRuntimeDependencies[pkg.name] ?? [];
+    const forcedRuntimeDevDeps = packageRuntimeDevDependencies[pkg.name] ?? [];
+    const [rootPackageJson, pkgJson] = await Promise.all([pkg.workspace.getPackageJson(), pkg.getPackageJson()]);
+    const optionalPeerDeps = new Set(Object.entries(pkgJson.peerDependenciesMeta ?? {}).filter(([, meta]) => meta.optional).map(([dep]) => dep));
+    const packageRuntimeDeps = [...new Set([...npmDeps, ...forcedRuntimeDeps])].filter((dep) => !optionalPeerDeps.has(dep) && !bundledRuntimeDeps.has(dep));
+    const packageRuntimeDevDeps = [...new Set([...npmDevDeps, ...forcedRuntimeDevDeps])].filter((dep) => !optionalPeerDeps.has(dep));
+    const rootDeps = { ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies };
+    const missingForcedDeps = forcedRuntimeDeps.filter((dep) => !rootDeps[dep]);
+    const missingForcedDevDeps = forcedRuntimeDevDeps.filter((dep) => !rootDeps[dep]);
+    const requiredMissingDeps = missingDeps.filter((dep) => !optionalPeerDeps.has(dep));
+    const allMissingDeps = [...new Set([...requiredMissingDeps, ...missingForcedDeps, ...missingForcedDevDeps])].sort();
+    if (allMissingDeps.length > 0)
+      throw new Error(`Missing dependency versions in root package.json: ${allMissingDeps.join(", ")}`);
+    await pkg.updatePackageJsonDependencies(packageRuntimeDeps, packageRuntimeDevDeps);
+    const hasBuildFile = await Bun.file(`${pkg.cwdPath}/build.ts`).exists();
+    if (hasBuildFile) {
+      await pkg.workspace.spawn(process.execPath, [`${pkg.cwdPath}/build.ts`], {
+        env: {
+          ...process.env,
+          ...pkg.name === "akanjs" ? { AKAN_BUILD_DECLARATION_DIAGNOSTICS: "error" } : {}
+        },
+        stdio: "inherit"
+      });
+    } else {
+      await $`cp -r ${pkg.cwdPath}/. ${pkg.dist.cwdPath}`;
+      await Promise.all([
+        pkg.generateDistPackageJson(packageRuntimeDeps, packageRuntimeDevDeps),
+        pkg.generateTsconfigJson()
+      ]);
+    }
+    await this.#copyPackageReadmes(pkg);
+  }
+  async verifyDistPackage(pkg) {
+    const distPackageJsonPath = `${pkg.dist.cwdPath}/package.json`;
+    if (!await Bun.file(distPackageJsonPath).exists()) {
+      throw new Error(`[package] dist package not found for ${pkg.name}. Run build-package first.`);
+    }
+    const pkgJson = await FileSys.readJson(distPackageJsonPath);
+    if (pkgJson.name !== pkg.name) {
+      throw new Error(`[package] dist package name mismatch: expected ${pkg.name}, got ${pkgJson.name ?? "(missing)"}`);
+    }
+    if (!pkgJson.version)
+      throw new Error(`[package] dist package version is missing for ${pkg.name}`);
+    if (!pkgJson.publishConfig || pkgJson.publishConfig.access !== "public") {
+      throw new Error(`[package] ${pkg.name} must publish with publishConfig.access=public`);
+    }
+    if (!await Bun.file(`${pkg.dist.cwdPath}/README.md`).exists()) {
+      throw new Error(`[package] README.md is missing from dist package ${pkg.name}`);
+    }
+    if (!await Bun.file(`${pkg.dist.cwdPath}/README.ko.md`).exists()) {
+      throw new Error(`[package] README.ko.md is missing from dist package ${pkg.name}`);
+    }
+    const binEntries = typeof pkgJson.bin === "string" ? [pkgJson.bin] : Object.values(pkgJson.bin ?? {});
+    if (binEntries.some((binPath) => binPath.endsWith(".ts"))) {
+      throw new Error(`[package] ${pkg.name} dist bin entries must not point at TypeScript sources`);
+    }
+    if (pkg.name === "akanjs") {
+      const exports = pkgJson.exports;
+      const rootExport = exports?.["."];
+      if (!rootExport?.types?.startsWith("./types/")) {
+        throw new Error("[package] akanjs dist exports must point type declarations at ./types");
+      }
+    }
+    const packOutput = await pkg.workspace.spawn("npm", ["pack", "--dry-run", "--json", pkg.dist.cwdPath], {
+      cwd: pkg.workspace.workspaceRoot
+    });
+    const [packResult] = JSON.parse(packOutput);
+    return {
+      name: pkg.name,
+      version: pkgJson.version,
+      files: packResult?.files?.length ?? 0,
+      size: packResult?.size ?? 0
+    };
+  }
+  async verifyAkanPublishPackages(workspace) {
+    const results = [];
+    for (const pkgName of PackageRunner.publishableAkanPackages) {
+      results.push(await this.verifyDistPackage(PkgExecutor.from(workspace, pkgName)));
+    }
+    return results;
+  }
+  async#copyPackageReadmes(pkg) {
+    await Promise.all(["README.md", "README.ko.md"].map((fileName) => pkg.cp(fileName, `${pkg.dist.cwdPath}/${fileName}`)));
+  }
+  async updateWorskpaceRootPackageJson(workspace, rootPackageJson) {
+    const templatePath = "pkgs/@akanjs/cli/templates/workspaceRoot/package.json.template";
+    const pkgJsonTemplate = await workspace.readJson(templatePath);
+    const { dependencies = {}, devDependencies = {} } = pkgJsonTemplate;
+    const newRootPackageJson = {
+      ...pkgJsonTemplate,
+      dependencies: Object.fromEntries(Object.entries(dependencies).map(([key, value]) => [key, rootPackageJson.dependencies?.[key] ?? value])),
+      devDependencies: Object.fromEntries(Object.entries(devDependencies).map(([key, value]) => [key, rootPackageJson.devDependencies?.[key] ?? value]))
+    };
+    await workspace.writeJson(templatePath, newRootPackageJson);
+  }
+}
+
+// pkgs/@akanjs/cli/package/package.script.ts
+class PackageScript extends script("package", [PackageRunner]) {
+  async version(workspace, { log = true } = {}) {
+    return await this.packageRunner.version(workspace, { log });
+  }
+  async createPackage(workspace, pkgName) {
+    const spinner = workspace.spinning(`Creating package in pkgs/${pkgName}...`);
+    await this.packageRunner.createPackage(workspace, pkgName);
+    spinner.succeed(`Package in pkgs/${pkgName} is created`);
+  }
+  async removePackage(pkg) {
+    const spinner = pkg.spinning(`Removing package in pkgs/${pkg.name}...`);
+    await this.packageRunner.removePackage(pkg);
+    spinner.succeed("Package removed");
+  }
+  async syncPackage(pkg) {
+    const spinner = pkg.spinning("Scanning package...");
+    const scanResult = await this.packageRunner.scanSync(pkg);
+    spinner.succeed("Package scanned");
+    return scanResult;
+  }
+  async buildPackage(pkg, { showSpinner = true } = {}) {
+    const spinner = showSpinner ? pkg.spinning("Building package...") : undefined;
+    await this.packageRunner.buildPackage(pkg);
+    if (spinner)
+      spinner.succeed("Package built");
+  }
+  async verifyDistPackage(pkg) {
+    const spinner = pkg.spinning("Verifying dist package...");
+    const result = await this.packageRunner.verifyDistPackage(pkg);
+    spinner.succeed(`Package verified (${result.files} files, ${result.size} bytes packed)`);
+    return result;
+  }
+  async verifyAkanPublishPackages(workspace) {
+    const spinner = workspace.spinning("Verifying Akan publish packages...");
+    const results = await this.packageRunner.verifyAkanPublishPackages(workspace);
+    spinner.succeed(`Akan publish packages verified (${results.length} packages)`);
+    return results;
+  }
+  async updateWorskpaceRootPackageJson(workspace) {
+    const rootPackageJson = await workspace.getPackageJson();
+    await this.packageRunner.updateWorskpaceRootPackageJson(workspace, rootPackageJson);
+  }
+}
+
+export { PackageScript };