@akanjs/devkit 1.0.19 → 2.1.0-rc.0

package/createTunnel.ts

@@ -0,0 +1,36 @@
+import type { SshOptions } from "akanjs/base";
+
+import { type AppExecutor, WorkspaceExecutor } from "./executors";
+import { createSshTunnel } from "./sshTunnel";
+
+const getSshTunnelOptions = (app: AppExecutor, environment: string): SshOptions => {
+  const { serveDomain, repoName } = WorkspaceExecutor.getBaseDevEnv();
+  return {
+    host: `${app.name}-${environment}.${serveDomain}`,
+    port: process.env.SSH_TUNNEL_PORT ? parseInt(process.env.SSH_TUNNEL_PORT) : 32767,
+    username: process.env.SSH_TUNNEL_USERNAME ?? "root",
+    password: process.env.SSH_TUNNEL_PASSWORD ?? repoName,
+  };
+};
+
+interface TunnelOption {
+  app: AppExecutor;
+  environment: string;
+  port?: number;
+}
+export const createTunnel = async (
+  service: "redis" | "postgres",
+  { app, environment, port = service === "postgres" ? 5432 : 6379 }: TunnelOption,
+) => {
+  const sshOptions: SshOptions = getSshTunnelOptions(app, environment);
+  await createSshTunnel({
+    localHost: "0.0.0.0",
+    localPort: port,
+    srcHost: "0.0.0.0",
+    srcPort: port,
+    dstHost: `${service}-0.${service}-svc.${app.name}-${environment}.svc.cluster.local`,
+    dstPort: service === "postgres" ? 5432 : 6379,
+    sshOptions,
+  });
+  return `localhost:${port}`;
+};

package/dependencyScanner.ts

@@ -0,0 +1,357 @@
+import { builtinModules } from "node:module";
+import * as path from "node:path";
+import ignore from "ignore";
+import ts from "typescript";
+import type { App, Lib, Pkg } from "./commandDecorators";
+import { FileSys } from "./fileSys";
+import type { PackageJson, TsConfigJson } from "./types";
+
+const testFileRegex = /\.(?:test|spec)\.[cm]?[tj]sx?$/;
+const builtinModuleSet = new Set([...builtinModules, ...builtinModules.map((mod) => `node:${mod}`)]);
+const stripShebang = (source: string) => source.replace(/^#!.*(?:\r?\n|$)/, "");
+
+export class TypeScriptDependencyScanner {
+  #fileDependencies = new Map<string, string[]>();
+  #fileRuntimeDependencies = new Map<string, string[]>();
+  #fileTypeDependencies = new Map<string, string[]>();
+  #visitedFiles = new Set<string>();
+  readonly #tsTranspiler = new Bun.Transpiler({ loader: "ts" });
+  readonly #tsxTranspiler = new Bun.Transpiler({ loader: "tsx" });
+  private readonly directory: string;
+  private readonly rootPackageJson: PackageJson;
+  private readonly ig: ReturnType<typeof ignore>;
+  private readonly workspaceRoot: string;
+
+  constructor(
+    directory: string,
+    {
+      workspaceRoot,
+      rootPackageJson,
+      gitignorePatterns = [],
+    }: { workspaceRoot: string; tsconfig: TsConfigJson; rootPackageJson: PackageJson; gitignorePatterns?: string[] },
+  ) {
+    this.directory = directory;
+    this.rootPackageJson = rootPackageJson;
+    this.ig = ignore().add(gitignorePatterns);
+    this.workspaceRoot = workspaceRoot;
+  }
+
+  async getMonorepoDependencies(
+    projectName: string,
+    { pkgs = [], libs = [] }: { pkgs?: string[]; libs?: string[] } = {},
+  ): Promise<{ pkgDeps: string[]; libDeps: string[]; npmDeps: string[]; npmDevDeps: string[] }> {
+    const npmSet = new Set(
+      Object.keys({ ...this.rootPackageJson.dependencies, ...this.rootPackageJson.devDependencies }),
+    );
+    const pkgPathSet = new Set(pkgs);
+    const libPathSet = new Set(libs.map((lib) => `@libs/${lib}`));
+    await this.getDependencies();
+    const [npmDepSet, pkgPathDepSet, libPathDepSet] = this.#getImportSetsFromDependencies(
+      [npmSet, pkgPathSet, libPathSet],
+      this.#fileRuntimeDependencies,
+    );
+    const [npmDevDepSet] = this.#getImportSetsFromDependencies([npmSet], this.#fileTypeDependencies);
+    const pkgDeps = [...pkgPathDepSet];
+    const libDeps = [...libPathDepSet]
+      .map((path) => path.replace("@libs/", ""))
+      .filter((libName) => libName !== projectName);
+    return {
+      pkgDeps,
+      libDeps,
+      npmDeps: [...npmDepSet],
+      npmDevDeps: [...npmDevDepSet].filter((dep) => !npmDepSet.has(dep)),
+    };
+  }
+
+  async getPackageBuildDependencies(
+    projectName: string,
+  ): Promise<{ npmDeps: string[]; npmDevDeps: string[]; missingDeps: string[] }> {
+    const runtimeDeps = new Set<string>();
+    const devDeps = new Set<string>();
+    const sourceFiles = await this.#findTypeScriptFiles(this.directory, {
+      excludeBuildFiles: true,
+      excludeTestFiles: true,
+    });
+    const cssFiles = await this.#findCssFiles(this.directory);
+
+    for (const filePath of sourceFiles) {
+      const fileContent = await FileSys.readText(filePath);
+      const { imports, typeImports } = this.#extractImports(fileContent, filePath);
+      this.#addNormalizedImports(runtimeDeps, imports, projectName);
+      this.#addNormalizedImports(devDeps, typeImports, projectName);
+    }
+
+    for (const filePath of cssFiles) {
+      const fileContent = await FileSys.readText(filePath);
+      this.#addNormalizedImports(runtimeDeps, this.#extractCssPluginImports(fileContent), projectName);
+    }
+
+    const buildFilePath = path.join(this.directory, "build.ts");
+    if (await FileSys.fileExists(buildFilePath)) {
+      const fileContent = await FileSys.readText(buildFilePath);
+      const { imports, typeImports } = this.#extractImports(fileContent, buildFilePath);
+      this.#addNormalizedImports(devDeps, [...imports, ...typeImports], projectName);
+    }
+
+    for (const dep of runtimeDeps) devDeps.delete(dep);
+
+    const rootDeps = { ...this.rootPackageJson.dependencies, ...this.rootPackageJson.devDependencies };
+    const missingDeps: string[] = [];
+    for (const dep of [...runtimeDeps, ...devDeps]) {
+      if (rootDeps[dep] || (await this.#hasWorkspacePackage(dep))) continue;
+      missingDeps.push(dep);
+    }
+    return {
+      npmDeps: [...runtimeDeps].sort(),
+      npmDevDeps: [...devDeps].sort(),
+      missingDeps: missingDeps.sort(),
+    };
+  }
+
+  async #hasWorkspacePackage(dep: string) {
+    const packageJsonPath = path.join(this.workspaceRoot, "pkgs", dep, "package.json");
+    if (!(await Bun.file(packageJsonPath).exists())) return false;
+    try {
+      const packageJson = await FileSys.readJson<PackageJson>(packageJsonPath);
+      return packageJson.name === dep && !!packageJson.version;
+    } catch {
+      return false;
+    }
+  }
+
+  async getImportSets<DepSets extends Set<string>[]>(depSets: DepSets): Promise<DepSets> {
+    const fileDependencies = await this.getDependencies();
+    return this.#getImportSetsFromDependencies(depSets, fileDependencies);
+  }
+
+  #getImportSetsFromDependencies<DepSets extends Set<string>[]>(
+    depSets: DepSets,
+    fileDependencies: Map<string, string[]>,
+  ): DepSets {
+    const importedDepSets = new Array<Set<string>>(depSets.length);
+    for (let i = 0; i < depSets.length; i++) importedDepSets[i] = new Set<string>();
+    fileDependencies.forEach((imps) => {
+      imps.forEach((imp) => {
+        if (imp.startsWith(".")) return;
+        const moduleName = imp;
+        const moduleNameParts = moduleName.split("/");
+        const subModuleLength = moduleNameParts.length;
+        for (let i = 0; i < subModuleLength; i++) {
+          const importName = moduleNameParts.slice(0, i + 1).join("/");
+          for (let j = 0; j < depSets.length; j++) {
+            if (depSets[j]?.has(importName)) {
+              importedDepSets[j]?.add(importName);
+              return;
+            }
+          }
+        }
+      });
+    });
+    return importedDepSets as DepSets;
+  }
+
+  async getDependencies(): Promise<Map<string, string[]>> {
+    this.#fileDependencies.clear();
+    this.#fileRuntimeDependencies.clear();
+    this.#fileTypeDependencies.clear();
+    this.#visitedFiles.clear();
+
+    const files = await this.#findTypeScriptFiles(this.directory);
+
+    for (const file of files) await this.#analyzeFile(file, this.directory);
+
+    return this.#fileDependencies;
+  }
+
+  async #findTypeScriptFiles(
+    directory: string,
+    {
+      excludeBuildFiles = false,
+      excludeTestFiles = false,
+    }: { excludeBuildFiles?: boolean; excludeTestFiles?: boolean } = {},
+  ): Promise<string[]> {
+    const files: string[] = [];
+    const skipDirs = ["node_modules", "dist", "build", ".git", ".next", "public", "ios", "android"];
+
+    const glob = new Bun.Glob("**/*.{ts,tsx}");
+    for await (const filePath of glob.scan({ cwd: directory, onlyFiles: true })) {
+      if (skipDirs.some((dir) => filePath.includes(`/${dir}/`) || filePath.startsWith(`${dir}/`))) continue;
+      if (excludeBuildFiles && filePath === "build.ts") continue;
+      if (excludeTestFiles && testFileRegex.test(filePath)) continue;
+
+      const fullPath = path.join(directory, filePath);
+      const relativePath = path.relative(this.workspaceRoot, fullPath);
+      if (this.ig.ignores(relativePath)) continue;
+
+      files.push(fullPath);
+    }
+    return files;
+  }
+
+  async #findCssFiles(directory: string): Promise<string[]> {
+    const files: string[] = [];
+    const skipDirs = ["node_modules", "dist", "build", ".git", ".next", "public", "ios", "android"];
+    const glob = new Bun.Glob("**/*.css");
+    for await (const filePath of glob.scan({ cwd: directory, onlyFiles: true })) {
+      if (skipDirs.some((dir) => filePath.includes(`/${dir}/`) || filePath.startsWith(`${dir}/`))) continue;
+
+      const fullPath = path.join(directory, filePath);
+      const relativePath = path.relative(this.workspaceRoot, fullPath);
+      if (this.ig.ignores(relativePath)) continue;
+
+      files.push(fullPath);
+    }
+    return files;
+  }
+
+  async #analyzeFile(filePath: string, baseDir: string): Promise<void> {
+    if (this.#visitedFiles.has(filePath)) return;
+
+    this.#visitedFiles.add(filePath);
+
+    try {
+      const fileContent = await FileSys.readText(filePath);
+      const { imports, typeImports } = this.#extractImports(fileContent, filePath);
+
+      // Convert imports to absolute or relative paths
+      const resolvedImports = await this.#resolveImports(imports, filePath, baseDir);
+      const resolvedTypeImports = await this.#resolveImports(typeImports, filePath, baseDir);
+
+      // Store the dependencies
+      const relativePath = path.relative(baseDir, filePath);
+      this.#fileDependencies.set(relativePath, [...new Set([...resolvedImports, ...resolvedTypeImports])]);
+      this.#fileRuntimeDependencies.set(relativePath, resolvedImports);
+      this.#fileTypeDependencies.set(relativePath, resolvedTypeImports);
+    } catch {
+      // Ignore files that cannot be parsed or read during best-effort dependency scanning.
+    }
+  }
+
+  async #resolveImports(imports: string[], filePath: string, baseDir: string): Promise<string[]> {
+    return await Promise.all(
+      imports.map(async (importPath) => {
+        if (importPath.startsWith(".")) {
+          // Handle relative imports
+          const resolvedPath = `./${path.join(path.relative(baseDir, filePath), importPath)}`;
+          return await this.#ensureExtension(resolvedPath);
+        }
+        return importPath; // Keep package imports as is
+      }),
+    );
+  }
+
+  async #ensureExtension(filePath: string): Promise<string> {
+    if (await FileSys.fileExists(`${filePath}.ts`)) return `${filePath}.ts`;
+    else if (await FileSys.fileExists(`${filePath}.tsx`)) return `${filePath}.tsx`;
+    else if (await FileSys.fileExists(filePath)) return filePath;
+    return `${filePath}.ts`;
+  }
+
+  #extractImports(source: string, filePath: string) {
+    const transpiler = filePath.endsWith(".tsx") ? this.#tsxTranspiler : this.#tsTranspiler;
+    const scanSource = stripShebang(source);
+    const imports = new Set(
+      transpiler
+        .scanImports(scanSource)
+        .map((imp) => imp.path)
+        .filter(Boolean),
+    );
+    const typeImports = new Set<string>();
+
+    const sourceFile = ts.createSourceFile(filePath, scanSource, ts.ScriptTarget.Latest, true);
+    for (const statement of sourceFile.statements) {
+      if (!ts.isImportDeclaration(statement)) continue;
+      if (!ts.isStringLiteral(statement.moduleSpecifier)) continue;
+
+      const importPath = statement.moduleSpecifier.text;
+      const namedBindings = statement.importClause?.namedBindings;
+      const isNamedTypeOnlyImport =
+        namedBindings &&
+        ts.isNamedImports(namedBindings) &&
+        namedBindings.elements.length > 0 &&
+        namedBindings.elements.every((element) => element.isTypeOnly);
+
+      if ((statement.importClause?.isTypeOnly || isNamedTypeOnlyImport) && !imports.has(importPath)) {
+        typeImports.add(importPath);
+      }
+    }
+
+    return { imports: [...imports], typeImports: [...typeImports] };
+  }
+
+  #extractCssPluginImports(source: string) {
+    const imports = new Set<string>();
+    const pluginRegex = /@plugin\s+(?:url\()?["']([^"')]+)["']\)?/g;
+    for (const match of source.matchAll(pluginRegex)) {
+      const importPath = match[1];
+      if (importPath) imports.add(importPath);
+    }
+    return [...imports];
+  }
+
+  #addNormalizedImports(deps: Set<string>, imports: string[], projectName: string) {
+    for (const importPath of imports) {
+      const dep = this.#normalizePackageImport(importPath, projectName);
+      if (dep) deps.add(dep);
+    }
+  }
+
+  #normalizePackageImport(importPath: string, projectName: string): string | null {
+    if (
+      importPath.startsWith(".") ||
+      importPath.startsWith("/") ||
+      importPath.startsWith("#") ||
+      importPath.startsWith("bun:") ||
+      builtinModuleSet.has(importPath)
+    )
+      return null;
+
+    const parts = importPath.split("/");
+    const packageName = importPath.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+    if (!packageName || packageName === projectName || importPath.startsWith(`${projectName}/`)) return null;
+    return packageName;
+  }
+
+  generateDependencyGraph(): string {
+    let graph = "Dependency Graph:\n\n";
+
+    for (const [file, imports] of this.#fileDependencies.entries()) {
+      graph += `${file}:\n`;
+
+      const projectImports = imports.filter((i) => !i.startsWith("react") && !i.startsWith("@"));
+      const externalImports = imports.filter((i) => i.startsWith("react") || i.startsWith("@"));
+
+      if (projectImports.length > 0) {
+        graph += "  Project dependencies:\n";
+        projectImports.forEach((imp) => {
+          graph += `    → ${imp}\n`;
+        });
+      }
+
+      if (externalImports.length > 0) {
+        graph += "  External dependencies:\n";
+        externalImports.forEach((imp) => {
+          graph += `    → ${imp}\n`;
+        });
+      }
+
+      graph += "\n";
+    }
+
+    return graph;
+  }
+
+  static async from(exec: App | Lib | Pkg) {
+    const [tsconfig, rootPackageJson, gitignorePatterns] = await Promise.all([
+      exec.getTsConfig(),
+      exec.workspace.getPackageJson(),
+      exec.workspace.getGitignorePatterns(),
+    ]);
+    return new TypeScriptDependencyScanner(exec.cwdPath, {
+      workspaceRoot: exec.workspace.cwdPath,
+      tsconfig,
+      rootPackageJson,
+      gitignorePatterns,
+    });
+  }
+}

package/devkitUtils.test.ts

@@ -0,0 +1,259 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { ApplicationBuildReporter } from "./applicationBuildReporter";
+import { TypeScriptDependencyScanner } from "./dependencyScanner";
+import { extractDependencies } from "./extractDeps";
+import { getModelFileData } from "./getModelFileData";
+import type { PackageJson, TsConfigJson } from "./types";
+
+const tempRoots: string[] = [];
+
+const makeTempRoot = async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "akan-devkit-utils-"));
+  tempRoots.push(root);
+  return root;
+};
+
+const write = async (filePath: string, content: string) => {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, content);
+};
+
+afterEach(async () => {
+  await Promise.all(tempRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+
+describe("extractDependencies", () => {
+  const packageJson: PackageJson = {
+    name: "fixture",
+    version: "1.0.0",
+    description: "fixture",
+    dependencies: {
+      react: "19.0.0",
+      "@scope/pkg": "1.0.0",
+      lodash: "4.0.0",
+    },
+    devDependencies: {
+      typescript: "6.0.0",
+      vite: "5.0.0",
+    },
+  };
+
+  test("extracts runtime package versions from imports and requires", () => {
+    const deps = extractDependencies(
+      [
+        {
+          path: "index.ts",
+          text: [
+            'import React from "react";',
+            'import { value } from "@scope/pkg/subpath";',
+            'import type { Type } from "typescript";',
+            'const lodash = require("lodash/fp");',
+            'const fs = require("node:fs");',
+            'const path = require("path");',
+            "",
+          ].join("\n"),
+        },
+        { path: "style.css", text: '@import "vite";' },
+      ],
+      packageJson,
+      ["vite"],
+    );
+
+    expect(deps).toEqual({
+      "@scope/pkg": "1.0.0",
+      lodash: "4.0.0",
+      react: "19.0.0",
+      typescript: "6.0.0",
+      vite: "5.0.0",
+    });
+  });
+
+  test("reports missing dependency sections and missing versions", () => {
+    expect(() =>
+      extractDependencies([{ path: "index.ts", text: 'import React from "react";' }], {
+        name: "broken",
+        version: "1.0.0",
+        description: "broken",
+      }),
+    ).toThrow("No dependencies found");
+
+    expect(() => extractDependencies([], packageJson, ["missing"])).toThrow("No version found for missing");
+  });
+});
+
+describe("TypeScriptDependencyScanner", () => {
+  test("separates monorepo package, lib, runtime, and type-only dependencies", async () => {
+    const root = await makeTempRoot();
+    const appDir = path.join(root, "apps/demo");
+    await write(
+      path.join(appDir, "index.ts"),
+      [
+        'import React from "react";',
+        'import { helper } from "@libs/shared/helper";',
+        'import { tool } from "akanjs/tool";',
+        'import type { Config } from "typescript";',
+        'import { local } from "./local";',
+        "console.log(React, helper, tool, local);",
+        "",
+      ].join("\n"),
+    );
+    await write(path.join(appDir, "local.ts"), 'import "lodash";\nexport const local = 1;\n');
+    await write(path.join(appDir, "node_modules/ignored.ts"), 'import "ignored";\n');
+    await write(path.join(root, ".gitignore"), "ignored-dir\n");
+
+    const rootPackageJson: PackageJson = {
+      name: "repo",
+      version: "1.0.0",
+      description: "repo",
+      dependencies: {
+        react: "19.0.0",
+        lodash: "4.0.0",
+      },
+      devDependencies: {
+        typescript: "6.0.0",
+      },
+    };
+    const tsconfig: TsConfigJson = { compilerOptions: { target: "ESNext" } };
+    const scanner = new TypeScriptDependencyScanner(appDir, {
+      workspaceRoot: root,
+      tsconfig,
+      rootPackageJson,
+      gitignorePatterns: ["ignored-dir"],
+    });
+
+    const deps = await scanner.getMonorepoDependencies("demo", {
+      pkgs: ["akanjs/tool"],
+      libs: ["shared"],
+    });
+    expect(deps.pkgDeps).toEqual(["akanjs/tool"]);
+    expect(deps.libDeps).toEqual(["shared"]);
+    expect(deps.npmDeps.sort()).toEqual(["lodash", "react"]);
+    expect(deps.npmDevDeps).toEqual(["typescript"]);
+
+    const graph = scanner.generateDependencyGraph();
+    expect(graph).toContain("index.ts");
+    expect(graph).toContain("@libs/shared/helper");
+  });
+
+  test("scans package build dependencies with normalized imports and css plugins", async () => {
+    const root = await makeTempRoot();
+    const pkgDir = path.join(root, "pkgs/akanjs");
+    await write(
+      path.join(pkgDir, "index.ts"),
+      [
+        "#!/usr/bin/env bun",
+        'import "lodash/fp";',
+        'import { AiOutlineApi } from "react-icons/ai";',
+        'import type { Config } from "typescript";',
+        'import type { DebouncedFunc } from "lodash";',
+        'import "node:path";',
+        'import "bun:test";',
+        'import "akanjs/client";',
+        "export const value = AiOutlineApi;",
+        "export type ToolConfig = Config & { debounced?: DebouncedFunc<() => void> };",
+        "",
+      ].join("\n"),
+    );
+    await write(path.join(pkgDir, "styles.css"), '@plugin "tailwind-scrollbar";\n');
+    await write(path.join(pkgDir, "index.test.ts"), 'import "commander";\n');
+    await write(path.join(pkgDir, "build.ts"), 'import { Command } from "commander";\n');
+    await write(path.join(pkgDir, "commented.ts"), '// import type { Linter } from "eslint";\n');
+
+    const rootPackageJson: PackageJson = {
+      name: "repo",
+      version: "1.0.0",
+      description: "repo",
+      dependencies: {
+        lodash: "4.0.0",
+        "react-icons": "5.0.0",
+        "tailwind-scrollbar": "4.0.0",
+      },
+      devDependencies: {
+        commander: "14.0.0",
+        typescript: "6.0.0",
+      },
+    };
+    const tsconfig: TsConfigJson = { compilerOptions: { target: "ESNext" } };
+    const scanner = new TypeScriptDependencyScanner(pkgDir, {
+      workspaceRoot: root,
+      tsconfig,
+      rootPackageJson,
+    });
+
+    const deps = await scanner.getPackageBuildDependencies("akanjs");
+
+    expect(deps.npmDeps).toEqual(["lodash", "react-icons", "tailwind-scrollbar"]);
+    expect(deps.npmDevDeps).toEqual(["commander", "typescript"]);
+    expect(deps.missingDeps).toEqual([]);
+  });
+});
+
+describe("getModelFileData", () => {
+  test("reads model files and derives imported local, scalar, and lib models", async () => {
+    const root = await makeTempRoot();
+    const cwd = process.cwd();
+    process.chdir(root);
+    try {
+      await write(
+        path.join(root, "apps/demo/lib/post/post.constant.ts"),
+        [
+          'import { cnst as shared } from "@libs/shared";',
+          'import { User } from "../user/user.constant";',
+          'import { Money } from "../_money/money.constant";',
+          "export const Post = {};",
+          "",
+        ].join("\n"),
+      );
+      await write(
+        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"),
+        "export default function View() { return null; }\n",
+      );
+
+      const data = await getModelFileData("apps/demo", "post");
+      expect(data).toMatchObject({
+        moduleType: "app",
+        moduleName: "demo",
+        modelName: "post",
+        importModelNames: ["user"],
+        hasImportScalar: true,
+        importLibNames: ["shared"],
+      });
+      expect(data.constantFileStr).toContain("export const Post");
+      expect(data.unitFileStr).toContain("Unit");
+      expect(data.viewFileStr).toContain("View");
+    } finally {
+      process.chdir(cwd);
+    }
+  });
+});
+
+describe("ApplicationBuildReporter", () => {
+  test("formats duration, phase lines, and nested errors", () => {
+    expect(ApplicationBuildReporter.formatDuration(999)).toBe("999ms");
+    expect(ApplicationBuildReporter.formatDuration(1234)).toBe("1.2s");
+    expect(ApplicationBuildReporter.formatDuration(65_000)).toBe("1m 5s");
+    expect(
+      ApplicationBuildReporter.formatPhaseLine({
+        id: "bundle",
+        label: "Bundle",
+        durationMs: 1500,
+        summary: "3 files",
+      }),
+    ).toBe("✓ Bundle: 3 files (1.5s)");
+
+    const nested = new Error("outer", { cause: new Error("inner") });
+    expect(ApplicationBuildReporter.formatError(nested)).toBe("outer\nCaused by: inner");
+
+    const aggregate = new AggregateError([new Error("first"), { message: "second" }, "third"], "failed");
+    expect(ApplicationBuildReporter.formatError(aggregate)).toBe(
+      ["failed", "  first", "  second", "  third"].join("\n"),
+    );
+  });
+});