@akanjs/devkit 3.0.0-alpha.85 → 3.0.0-alpha.86

package/biome.base.json

@@ -60,10 +60,10 @@
       }
     },
     "domains": {
-      "project": "none",
+      "project": "recommended",
       "react": "recommended",
       "test": "recommended",
-      "types": "none"
+      "types": "all"
     }
   },
   "javascript": {

package/biomeBase.ts

@@ -1,16 +1,9 @@
 /** `extends` target for a workspace `biome.json`; Biome resolves it through node_modules. */
 export const biomeBaseConfig = "@akanjs/devkit/biome.base.json";
 
-// The `types` and `project` domains are the two that make Biome build a type and a module graph, so `biome.base.json`
-// leaves them `none` and the editor never pays for them on save. They live here instead, applied on top of the base
-// by the batch runners through `BiomeStrictConfig`. Omitting a domain is not the same as `none` — Biome infers an
-// unspecified domain from the project's dependencies and turns it on — so both files spell every domain out.
-export const biomeDomainsConfig = "@akanjs/devkit/biome.domains.json";
-
 // Biome moves rules between groups across minors — `noUnnecessaryConditions` sat in `nursery` at 2.4 and moved to
 // `suspicious` at 2.5 — and the stale position is a hard "unknown key" error, not a warning. A workspace whose
 // Biome disagrees with the shipped base config therefore fails to load it at all, which is why the version is
-// pinned here instead of resolved to latest at create time. Bump this, `biome.base.json` and `biome.domains.json`
-// in one commit, and run `biome migrate --write` in the workspace root and in `pkgs/@akanjs/devkit` so every config
-// moves together.
+// pinned here instead of resolved to latest at create time. Bump this and `biome.base.json` in one commit, and run
+// `biome migrate --write` in the workspace root and in `pkgs/@akanjs/devkit` so both configs move together.
 export const biomeVersion = "2.5.12";

package/frontendBuild/sourceMtimeIndex.ts

@@ -377,7 +377,7 @@ export class SourceMtimeIndex {
     return !name || name.startsWith(".") || name === "node_modules";
   }
 
-  /** `WatchRootResolver` can return `apps/<app>/page` alongside `apps/`; walking both doubles the work. */
+  /** `WatchRootResolver` can return `apps/<app>/page` alongside `apps/<app>`; walking both doubles the work. */
   static #pruneNestedRoots(roots: string[]): string[] {
     const resolved = [...new Set(roots.map((root) => path.resolve(root)))].sort();
     return resolved.filter(

package/frontendBuild/watchRootResolver.test.ts

@@ -0,0 +1,67 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import type { App } from "../commandDecorators";
+import { WatchRootResolver } from "./watchRootResolver";
+
+const roots: string[] = [];
+
+const makeWorkspace = async (dirs: string[]) => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "akan-watch-roots-"));
+  roots.push(root);
+  await Promise.all(dirs.map((dir) => mkdir(path.join(root, dir), { recursive: true })));
+  return root;
+};
+
+const makeApp = (workspaceRoot: string, name: string, paths: Record<string, string[]>) =>
+  ({
+    cwdPath: path.join(workspaceRoot, "apps", name),
+    workspace: { workspaceRoot },
+    getTsConfig: async () => ({ compilerOptions: { paths } }),
+  }) as unknown as App;
+
+afterEach(async () => {
+  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+
+describe("WatchRootResolver", () => {
+  test("narrows the apps container to the app being served", async () => {
+    const workspaceRoot = await makeWorkspace(["apps/app1/page", "apps/app2/page", "libs/util"]);
+    const resolved = await new WatchRootResolver(
+      makeApp(workspaceRoot, "app1", { "@apps/*": ["./apps/*"], "@libs/*": ["./libs/*"] }),
+    ).resolve();
+
+    expect(resolved).toContain(path.join(workspaceRoot, "apps/app1"));
+    expect(resolved).not.toContain(path.join(workspaceRoot, "apps"));
+    expect(resolved).not.toContain(path.join(workspaceRoot, "apps/app2"));
+  });
+
+  test("keeps the libs container whole", async () => {
+    const workspaceRoot = await makeWorkspace(["apps/app1/page", "libs/util", "libs/shared"]);
+    const resolved = await new WatchRootResolver(makeApp(workspaceRoot, "app1", { "@libs/*": ["./libs/*"] })).resolve();
+
+    expect(resolved).toContain(path.join(workspaceRoot, "libs"));
+  });
+
+  test("resolves a package alias to its own directory, filename and glob stripped", async () => {
+    const workspaceRoot = await makeWorkspace(["apps/app1/page", "pkgs/akanjs/base"]);
+    const resolved = await new WatchRootResolver(
+      makeApp(workspaceRoot, "app1", {
+        akanjs: ["./pkgs/akanjs/index.ts"],
+        "akanjs/*": ["./pkgs/akanjs/*"],
+        missing: ["./pkgs/nothing/index.ts"],
+      }),
+    ).resolve();
+
+    expect(resolved).toContain(path.join(workspaceRoot, "pkgs/akanjs"));
+    expect(resolved).not.toContain(path.join(workspaceRoot, "pkgs/nothing"));
+  });
+
+  test("always watches the app's page tree", async () => {
+    const workspaceRoot = await makeWorkspace(["apps/app1/page"]);
+    const resolved = await new WatchRootResolver(makeApp(workspaceRoot, "app1", {})).resolve();
+
+    expect(resolved).toEqual([path.join(workspaceRoot, "apps/app1/page")]);
+  });
+});

package/frontendBuild/watchRootResolver.ts

@@ -2,6 +2,15 @@ import fs from "node:fs";
 import path from "node:path";
 import type { App } from "../commandDecorators";
 
+/**
+ * The directories one app's dev watcher follows, resolved from its tsconfig `paths`.
+ *
+ * `@apps/*` strips down to the `apps/` container, so taking it verbatim puts every sibling app under the
+ * watcher: with two dev servers up, a save in app2 rebuilds, restarts and reloads app1, and both builders
+ * rewrite the same generated barrels. Apps are leaves of the workspace graph — never one another's
+ * dependencies — so the container is replaced by this app's own directory. `libs/` stays whole, because a
+ * lib becomes a dependency the moment someone types the import, with no restart in between.
+ */
 export class WatchRootResolver {
   #app: App;
 
@@ -11,6 +20,8 @@ export class WatchRootResolver {
 
   async resolve(): Promise<string[]> {
     const tsconfig = await this.#app.getTsConfig();
+    const appDir = path.resolve(this.#app.cwdPath);
+    const appsContainer = path.dirname(appDir);
     const set = new Set<string>();
     set.add(path.resolve(`${this.#app.cwdPath}/page`));
     for (const targets of Object.values(tsconfig.compilerOptions.paths ?? {})) {
@@ -20,7 +31,8 @@ export class WatchRootResolver {
         // Strip the trailing filename and glob so we watch the package root dir.
         const cleaned = target.replace(/\/?\*+.*$/, "").replace(/\/[^/]+\.[^/]+$/, "");
         const resolved = path.resolve(this.#app.workspace.workspaceRoot, cleaned);
-        if (fs.existsSync(resolved)) set.add(resolved);
+        const root = resolved === appsContainer ? appDir : resolved;
+        if (fs.existsSync(root)) set.add(root);
       }
     }
     return [...set];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "3.0.0-alpha.85",
+  "version": "3.0.0-alpha.86",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -24,7 +24,6 @@
     },
     "./package.json": "./package.json",
     "./biome.base.json": "./biome.base.json",
-    "./biome.domains.json": "./biome.domains.json",
     "./akanApp": "./akanApp/index.ts",
     "./akanConfig": "./akanConfig/index.ts",
     "./artifact": "./artifact/index.ts",
@@ -46,7 +45,7 @@
     "@langchain/openai": "^1.4.6",
     "@tailwindcss/node": "^4.3.0",
     "@trapezedev/project": "^7.1.4",
-    "akanjs": "3.0.0-alpha.85",
+    "akanjs": "3.0.0-alpha.86",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "dayjs": "^1.11.20",

package/biome.domains.json

@@ -1,9 +0,0 @@
-{
-  "$schema": "https://biomejs.dev/schemas/2.5.12/schema.json",
-  "linter": {
-    "domains": {
-      "project": "recommended",
-      "types": "all"
-    }
-  }
-}

package/biomeStrictConfig.test.ts

@@ -1,54 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { mkdtemp } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { BiomeStrictConfig } from "./biomeStrictConfig";
-
-const workspace = async () => await mkdtemp(path.join(tmpdir(), "akan-biome-strict-"));
-
-describe("BiomeStrictConfig", () => {
-  test("writes nothing when the workspace has no biome config", async () => {
-    const root = await workspace();
-    const strictConfig = new BiomeStrictConfig(root);
-
-    expect(await strictConfig.write()).toBeNull();
-    expect(await Bun.file(strictConfig.filePath).exists()).toBe(false);
-  });
-
-  test("layers the domains over the workspace config, base first", async () => {
-    const root = await workspace();
-    await Bun.write(path.join(root, "biome.json"), "{}\n");
-    const strictConfig = new BiomeStrictConfig(root, { id: "test" });
-
-    const filePath = await strictConfig.write();
-
-    expect(filePath).toBe(path.join(root, ".biome.strict.test.json"));
-    expect(await Bun.file(path.join(root, ".biome.strict.test.json")).json()).toEqual({
-      extends: ["@akanjs/devkit/biome.base.json", "./biome.json", "@akanjs/devkit/biome.domains.json"],
-    });
-  });
-
-  test("prefers biome.json over biome.jsonc, mirroring Biome's own precedence", async () => {
-    const root = await workspace();
-    await Bun.write(path.join(root, "biome.json"), "{}\n");
-    await Bun.write(path.join(root, "biome.jsonc"), "{}\n");
-    const strictConfig = new BiomeStrictConfig(root, { id: "test" });
-
-    await strictConfig.write();
-
-    const written = (await Bun.file(strictConfig.filePath).json()) as { extends: string[] };
-    expect(written.extends[1]).toBe("./biome.json");
-  });
-
-  test("removes the copy, and stays quiet when there is nothing to remove", async () => {
-    const root = await workspace();
-    await Bun.write(path.join(root, "biome.jsonc"), "{}\n");
-    const strictConfig = new BiomeStrictConfig(root, { id: "test" });
-    await strictConfig.write();
-
-    await strictConfig.remove();
-    await strictConfig.remove();
-
-    expect(await Bun.file(strictConfig.filePath).exists()).toBe(false);
-  });
-});

package/biomeStrictConfig.ts

@@ -1,58 +0,0 @@
-import { rm } from "node:fs/promises";
-import path from "node:path";
-import { biomeBaseConfig, biomeDomainsConfig } from "./biomeBase";
-
-/**
- * The editor and the batch runs want different `linter.domains`, and Biome has no per-invocation switch for them:
- * `--only` / `--skip` pick which rules run, not whether the type and module graphs are built, and `--only=<domain>`
- * additionally force-enables every rule of that domain, including the ones the shared config deliberately leaves
- * off. So the domains are a configuration difference, and this class is the batch half of it — a throwaway config
- * that re-applies `biome.domains.json` over the workspace's own, used by `akan lint` and the pre-commit hook.
- *
- * Two details fix its shape. It has to sit in the workspace root, because Biome resolves `plugins` paths from the
- * entry configuration's own directory — a config under `.husky/` loads none of the grit rules and reports only
- * "Cannot read file". And it has to name `biome.base.json` itself rather than lean on the workspace config's own
- * `extends`, because `extends` is one level deep: a config extending `./biome.json` inherits `biome.json`'s own
- * keys and nothing that `biome.json` in turn extends. Listing the base first keeps `overrides` in the order a
- * plain run has them, workspace entries after the framework's.
- */
-export class BiomeStrictConfig {
-  static readonly configFileNames = ["biome.json", "biome.jsonc"] as const;
-
-  /** `biome.json` first, mirroring Biome's own precedence; `biome.jsonc` is the one that may carry comments. */
-  static async resolveConfigName(workspaceRoot: string): Promise<string | null> {
-    for (const fileName of BiomeStrictConfig.configFileNames) {
-      if (await Bun.file(path.join(workspaceRoot, fileName)).exists()) return fileName;
-    }
-    return null;
-  }
-
-  readonly #filePath: string;
-  readonly #workspaceRoot: string;
-
-  constructor(workspaceRoot: string, { id = process.pid }: { id?: number | string } = {}) {
-    this.#workspaceRoot = workspaceRoot;
-    this.#filePath = path.join(workspaceRoot, `.biome.strict.${id}.json`);
-  }
-
-  get filePath() {
-    return this.#filePath;
-  }
-
-  async write(): Promise<string | null> {
-    const configName = await BiomeStrictConfig.resolveConfigName(this.#workspaceRoot);
-    if (!configName) return null;
-    const config = { extends: [biomeBaseConfig, `./${configName}`, biomeDomainsConfig] };
-    await Bun.write(this.#filePath, `${JSON.stringify(config, null, 2)}\n`);
-    return this.#filePath;
-  }
-
-  async remove() {
-    await rm(this.#filePath, { force: true });
-  }
-}
-
-if (import.meta.main) {
-  const filePath = await new BiomeStrictConfig(process.cwd()).write();
-  if (filePath) process.stdout.write(path.relative(process.cwd(), filePath));
-}