@akanjs/devkit 2.2.10 → 2.2.12

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @akanjs/devkit
 
+## 2.2.12
+
+### Patch Changes
+
+- Updated dependencies [666e46c]
+- Updated dependencies [666e46c]
+  - akanjs@2.2.12
+
+## 2.2.11
+
+### Patch Changes
+
+- 8af7a9d: Add agent-oriented workspace context tooling, generated agent rule templates, and LLM documentation surfaces for Akan workspaces.
+- 8190632: Add Akan server console support with CLI/build integration and documentation for console-oriented workflows.
+- 4bce7f9: Add initial LLM discovery docs and stabilize Akan client/runtime behavior.
+
+  - Add `/llms.txt` documentation discovery for Akan docs.
+  - Add `wsConnect` support for automatic WebSocket connections.
+  - Delay client bootstrap module execution until the SSR fizz stream is ready.
+  - Improve route tree, HMR, fetch, store, and SSR/client runtime stability.
+
+- Updated dependencies [8190632]
+- Updated dependencies [4bce7f9]
+  - akanjs@2.2.11
+
 ## 2.2.7
 
 ### Patch Changes

package/akanContext.ts

@@ -0,0 +1,360 @@
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+import { capitalize } from "akanjs/common";
+import { AppExecutor, LibExecutor, type SysExecutor, type WorkspaceExecutor } from "./executors";
+import { FileSys } from "./fileSys";
+import type { PackageJson } from "./types";
+
+export type AkanContextFormat = "json" | "markdown";
+export type AkanModuleKind = "domain" | "service" | "scalar";
+export type AkanDiagnosticSeverity = "warning" | "error";
+
+export interface AkanAbstractSummary {
+  path: string;
+  exists: boolean;
+  title?: string;
+  headings: string[];
+  content?: string;
+}
+
+export interface AkanModuleContext {
+  kind: AkanModuleKind;
+  name: string;
+  folderName: string;
+  sysName: string;
+  sysType: "app" | "lib";
+  path: string;
+  abstract: AkanAbstractSummary;
+  files: string[];
+}
+
+export interface AkanSysContext {
+  type: "app" | "lib";
+  name: string;
+  path: string;
+  hasConfig: boolean;
+  modules: AkanModuleContext[];
+}
+
+export interface AkanPackageContext {
+  name: string;
+  path: string;
+  version?: string;
+}
+
+export interface AkanWorkspaceContext {
+  schemaVersion: 1;
+  repoName: string;
+  root: string;
+  packageVersion?: string;
+  apps: AkanSysContext[];
+  libs: AkanSysContext[];
+  pkgs: AkanPackageContext[];
+  generatedFiles: string[];
+  validationCommands: string[];
+}
+
+export interface AkanDiagnostic {
+  severity: AkanDiagnosticSeverity;
+  code: string;
+  message: string;
+  path?: string;
+}
+
+export interface AkanDoctorResult {
+  schemaVersion: 1;
+  strict: boolean;
+  diagnostics: AkanDiagnostic[];
+}
+
+export interface AkanContextOptions {
+  app?: string | null;
+  module?: string | null;
+  includeAbstractContent?: boolean;
+}
+
+const generatedFiles = [
+  "cnst.ts",
+  "db.ts",
+  "dict.ts",
+  "option.ts",
+  "sig.ts",
+  "srv.ts",
+  "st.ts",
+  "useClient.ts",
+  "useServer.ts",
+];
+
+const appRootAllowFiles = new Set([
+  "akan.app.json",
+  "akan.config.ts",
+  "capacitor.config.ts",
+  "client.ts",
+  "main.ts",
+  "package.json",
+  "server.ts",
+  "tsconfig.json",
+]);
+
+const appRootAllowDirs = new Set([
+  ".akan",
+  "android",
+  "common",
+  "env",
+  "ios",
+  "lib",
+  "page",
+  "private",
+  "public",
+  "script",
+  "srvkit",
+  "ui",
+  "webkit",
+]);
+
+const safeReadDir = async (dirPath: string) => {
+  try {
+    return (await readdir(dirPath, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
+  } catch {
+    return [];
+  }
+};
+
+const safeReadText = async (filePath: string) => {
+  try {
+    return await FileSys.readText(filePath);
+  } catch {
+    return null;
+  }
+};
+
+const safeReadJson = async <T>(filePath: string) => {
+  try {
+    return await FileSys.readJson<T>(filePath);
+  } catch {
+    return null;
+  }
+};
+
+const parseAbstractSummary = (
+  relativePath: string,
+  content: string | null,
+  includeContent: boolean,
+): AkanAbstractSummary => {
+  if (content === null) return { path: relativePath, exists: false, headings: [] };
+  const headings = content
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith("#"))
+    .map((line) => line.replace(/^#+\s*/, "").trim())
+    .filter(Boolean);
+  return {
+    path: relativePath,
+    exists: true,
+    title: headings[0],
+    headings: headings.slice(0, 8),
+    ...(includeContent ? { content } : {}),
+  };
+};
+
+const readFiles = async (dirPath: string) =>
+  (await safeReadDir(dirPath))
+    .filter((entry) => entry.isFile())
+    .map((entry) => entry.name)
+    .sort();
+
+const getRelative = (workspace: WorkspaceExecutor, absolutePath: string) =>
+  path.relative(workspace.workspaceRoot, absolutePath).replaceAll(path.sep, "/");
+
+const createModuleContext = async (
+  workspace: WorkspaceExecutor,
+  sys: SysExecutor,
+  kind: AkanModuleKind,
+  folderName: string,
+  moduleName: string,
+  includeAbstractContent: boolean,
+): Promise<AkanModuleContext> => {
+  const modulePath =
+    kind === "scalar"
+      ? path.join(sys.cwdPath, "lib", "__scalar", moduleName)
+      : path.join(sys.cwdPath, "lib", folderName);
+  const relativePath = getRelative(workspace, modulePath);
+  const abstractPath = `${relativePath}/${moduleName}.abstract.md`;
+  const abstractContent = await safeReadText(path.join(workspace.workspaceRoot, abstractPath));
+  return {
+    kind,
+    name: moduleName,
+    folderName,
+    sysName: sys.name,
+    sysType: sys.type,
+    path: relativePath,
+    abstract: parseAbstractSummary(abstractPath, abstractContent, includeAbstractContent),
+    files: await readFiles(modulePath),
+  };
+};
+
+const getSysModules = async (
+  workspace: WorkspaceExecutor,
+  sys: SysExecutor,
+  {
+    includeAbstractContent = false,
+    module: moduleFilter,
+  }: { includeAbstractContent?: boolean; module?: string | null } = {},
+) => {
+  const libPath = path.join(sys.cwdPath, "lib");
+  const entries = await safeReadDir(libPath);
+  const modules: AkanModuleContext[] = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name === "__scalar") continue;
+    if (entry.name.startsWith("__")) continue;
+    if (entry.name.startsWith("_")) {
+      const serviceName = entry.name.replace(/^_+/, "");
+      if (moduleFilter && moduleFilter !== serviceName && moduleFilter !== entry.name) continue;
+      if (!(await FileSys.fileExists(path.join(libPath, entry.name, `${serviceName}.service.ts`)))) continue;
+      modules.push(
+        await createModuleContext(workspace, sys, "service", entry.name, serviceName, includeAbstractContent),
+      );
+    } else {
+      if (moduleFilter && moduleFilter !== entry.name) continue;
+      if (!(await FileSys.fileExists(path.join(libPath, entry.name, `${entry.name}.constant.ts`)))) continue;
+      modules.push(await createModuleContext(workspace, sys, "domain", entry.name, entry.name, includeAbstractContent));
+    }
+  }
+
+  const scalarRoot = path.join(libPath, "__scalar");
+  for (const entry of await safeReadDir(scalarRoot)) {
+    if (!entry.isDirectory() || entry.name.startsWith("_")) continue;
+    if (moduleFilter && moduleFilter !== entry.name) continue;
+    if (!(await FileSys.fileExists(path.join(scalarRoot, entry.name, `${entry.name}.constant.ts`)))) continue;
+    modules.push(await createModuleContext(workspace, sys, "scalar", entry.name, entry.name, includeAbstractContent));
+  }
+
+  return modules.sort((a, b) => `${a.sysName}:${a.path}`.localeCompare(`${b.sysName}:${b.path}`));
+};
+
+const getSysContext = async (
+  workspace: WorkspaceExecutor,
+  type: "app" | "lib",
+  name: string,
+  options: AkanContextOptions,
+): Promise<AkanSysContext> => {
+  const sys = type === "app" ? AppExecutor.from(workspace, name) : LibExecutor.from(workspace, name);
+  return {
+    type,
+    name,
+    path: `${type}s/${name}`,
+    hasConfig: await FileSys.fileExists(path.join(sys.cwdPath, "akan.config.ts")),
+    modules: await getSysModules(workspace, sys, {
+      includeAbstractContent: options.includeAbstractContent,
+      module: options.module,
+    }),
+  };
+};
+
+export class AkanContextAnalyzer {
+  static async analyze(workspace: WorkspaceExecutor, options: AkanContextOptions = {}): Promise<AkanWorkspaceContext> {
+    const [appNames, libNames, pkgNames] = await workspace.getExecs();
+    const rootPackageJson = await safeReadJson<PackageJson>(path.join(workspace.workspaceRoot, "package.json"));
+    const filteredApps = options.app ? appNames.filter((name) => name === options.app) : appNames;
+    const [apps, libs, pkgs] = await Promise.all([
+      Promise.all(filteredApps.map((name) => getSysContext(workspace, "app", name, options))),
+      Promise.all(libNames.map((name) => getSysContext(workspace, "lib", name, options))),
+      Promise.all(
+        pkgNames.map(async (name) => {
+          const packageJson = await safeReadJson<PackageJson>(
+            path.join(workspace.workspaceRoot, "pkgs", name, "package.json"),
+          );
+          return {
+            name,
+            path: `pkgs/${name}`,
+            ...(packageJson?.version ? { version: packageJson.version } : {}),
+          };
+        }),
+      ),
+    ]);
+
+    return {
+      schemaVersion: 1,
+      repoName: workspace.repoName,
+      root: workspace.workspaceRoot,
+      packageVersion: rootPackageJson?.dependencies?.akanjs ?? rootPackageJson?.devDependencies?.["@akanjs/devkit"],
+      apps,
+      libs,
+      pkgs,
+      generatedFiles,
+      validationCommands: ["akan lint <app-or-lib-or-pkg>", "akan build <app-name>", "akan start <app-name>"],
+    };
+  }
+
+  static async doctor(
+    workspace: WorkspaceExecutor,
+    { strict = false }: { strict?: boolean } = {},
+  ): Promise<AkanDoctorResult> {
+    const context = await AkanContextAnalyzer.analyze(workspace);
+    const diagnostics: AkanDiagnostic[] = [];
+
+    for (const app of context.apps) {
+      const appPath = path.join(workspace.workspaceRoot, app.path);
+      for (const entry of await safeReadDir(appPath)) {
+        const allowed = entry.isDirectory() ? appRootAllowDirs.has(entry.name) : appRootAllowFiles.has(entry.name);
+        if (!allowed) {
+          diagnostics.push({
+            severity: "warning",
+            code: "app-root-unknown-entry",
+            path: `${app.path}/${entry.name}`,
+            message: `Unexpected ${entry.isDirectory() ? "folder" : "file"} in app root: ${app.path}/${entry.name}`,
+          });
+        }
+      }
+    }
+
+    for (const sys of [...context.apps, ...context.libs]) {
+      for (const module of sys.modules) {
+        if (!module.abstract.exists) {
+          diagnostics.push({
+            severity: strict ? "error" : "warning",
+            code: "module-abstract-missing",
+            path: module.abstract.path,
+            message: `${capitalize(module.kind)} module ${sys.name}:${module.name} should include ${module.abstract.path}`,
+          });
+        }
+      }
+    }
+
+    return { schemaVersion: 1, strict, diagnostics };
+  }
+
+  static findModules(context: AkanWorkspaceContext, moduleName?: string | null) {
+    const modules = [...context.apps, ...context.libs].flatMap((sys) => sys.modules);
+    return moduleName
+      ? modules.filter((module) => module.name === moduleName || module.folderName === moduleName)
+      : modules;
+  }
+
+  static renderMarkdown(context: AkanWorkspaceContext, { module: moduleName }: { module?: string | null } = {}) {
+    const lines = [`# Akan Workspace Context`, "", `- Repo: ${context.repoName}`, `- Root: ${context.root}`];
+    if (context.packageVersion) lines.push(`- Akan version: ${context.packageVersion}`);
+    lines.push("", "## Apps", ...context.apps.map((app) => `- ${app.name}: ${app.modules.length} module(s)`));
+    lines.push("", "## Libraries", ...context.libs.map((lib) => `- ${lib.name}: ${lib.modules.length} module(s)`));
+    lines.push(
+      "",
+      "## Packages",
+      ...context.pkgs.map((pkg) => `- ${pkg.name}${pkg.version ? ` (${pkg.version})` : ""}`),
+    );
+
+    const modules = AkanContextAnalyzer.findModules(context, moduleName);
+    lines.push("", "## Modules");
+    for (const module of modules) {
+      lines.push("", `### ${module.sysName}:${module.name} (${module.kind})`, `- Path: ${module.path}`);
+      lines.push(`- Abstract: ${module.abstract.exists ? module.abstract.path : "missing"}`);
+      if (module.abstract.exists && module.abstract.content) lines.push("", module.abstract.content.trim(), "");
+      else if (module.abstract.headings.length)
+        lines.push(`- Abstract headings: ${module.abstract.headings.join(", ")}`);
+      lines.push(`- Files: ${module.files.join(", ") || "none"}`);
+    }
+
+    lines.push("", "## Validation", ...context.validationCommands.map((command) => `- \`${command}\``));
+    return `${lines.join("\n")}\n`;
+  }
+}

package/applicationBuildRunner.ts

@@ -184,6 +184,7 @@ export class ApplicationBuildRunner {
       outdir: this.#app.dist.cwdPath,
       target: "bun",
       minify: true,
+      naming: { entry: "[name].[ext]", chunk: "chunk-[hash].[ext]" },
       define: { "process.env.NODE_ENV": JSON.stringify("production") },
       plugins: backendExternals.length > 0 ? [this.#createExternalSpecifiersPlugin(backendExternals)] : [],
     });
@@ -198,12 +199,45 @@ export class ApplicationBuildRunner {
       define: { "process.env.NODE_ENV": JSON.stringify("production") },
       plugins: backendExternals.length > 0 ? [this.#createExternalSpecifiersPlugin(backendExternals)] : [],
     });
+    const consoleRuntimeResult = await this.#buildOrThrow("console-runtime", {
+      entrypoints: [this.#resolveConsoleRuntimeBuildEntry()],
+      outdir: this.#app.dist.cwdPath,
+      target: "bun",
+      minify: true,
+      naming: { entry: "console-runtime.[ext]", chunk: "chunk-[hash].[ext]" },
+      define: { "process.env.NODE_ENV": JSON.stringify("production") },
+    });
+    await this.#writeConsoleShim();
     return {
-      entrypoints: backendEntryPoints.length + 1,
-      outputs: backendResult.outputs.length + rscWorkerResult.outputs.length,
+      entrypoints: backendEntryPoints.length + 2,
+      outputs: backendResult.outputs.length + rscWorkerResult.outputs.length + consoleRuntimeResult.outputs.length + 1,
     };
   }
 
+  async #writeConsoleShim() {
+    await Bun.write(
+      path.join(this.#app.dist.cwdPath, "console.js"),
+      `import { cnst, db, dict, option, server, sig, srv } from "./server.js";
+import { assertAkanConsoleAllowed, startAkanConsole } from "./console-runtime.js";
+
+const run = async () => {
+  assertAkanConsoleAllowed(server.env);
+  await server.start({ listen: false, web: false });
+  try {
+    await startAkanConsole(server, { globals: { cnst, db, dict, option, sig, srv } });
+  } finally {
+    await server.stop();
+  }
+};
+
+void run().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});
+`,
+    );
+  }
+
   #resolveRscWorkerBuildEntry(): string {
     try {
       return Bun.resolveSync("akanjs/server/rsc-worker", import.meta.dir);
@@ -212,6 +246,14 @@ export class ApplicationBuildRunner {
     }
   }
 
+  #resolveConsoleRuntimeBuildEntry(): string {
+    try {
+      return path.join(path.dirname(Bun.resolveSync("akanjs/server", import.meta.dir)), "console.ts");
+    } catch {
+      return path.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/console.ts");
+    }
+  }
+
   async #buildCsr() {
     return await new CsrArtifactBuilder(this.#app, "build").build();
   }

package/devkitUtils.test.ts

@@ -5,6 +5,7 @@ import path from "node:path";
 import { ApplicationBuildReporter } from "./applicationBuildReporter";
 import { resolveSignalTestPreloadPath } from "./applicationTestPreload";
 import { TypeScriptDependencyScanner } from "./dependencyScanner";
+import { AppExecutor, WorkspaceExecutor } from "./executors";
 import { extractDependencies } from "./extractDeps";
 import { getModelFileData } from "./getModelFileData";
 import type { PackageJson, TsConfigJson } from "./types";
@@ -212,6 +213,45 @@ describe("TypeScriptDependencyScanner", () => {
   });
 });
 
+describe("scan convention", () => {
+  test("allows module abstract markdown files", async () => {
+    const root = await makeTempRoot();
+    const appName = "scanAbstractDemo";
+    const appDir = path.join(root, `apps/${appName}`);
+    await write(path.join(root, ".gitignore"), "");
+    await write(
+      path.join(root, ".env"),
+      ["AKAN_PUBLIC_REPO_NAME=repo", 'AKAN_PUBLIC_SERVE_DOMAIN="localhost"', "AKAN_PUBLIC_ENV=local", ""].join("\n"),
+    );
+    await write(
+      path.join(root, "package.json"),
+      JSON.stringify({
+        name: "repo",
+        version: "1.0.0",
+        description: "repo",
+        dependencies: {},
+        devDependencies: {},
+      }),
+    );
+    await write(path.join(root, "tsconfig.json"), JSON.stringify({ compilerOptions: { target: "ESNext", paths: {} } }));
+    await write(path.join(appDir, "package.json"), JSON.stringify({ name: appName, version: "1.0.0" }));
+    await write(path.join(appDir, "tsconfig.json"), JSON.stringify({ compilerOptions: { target: "ESNext" } }));
+    await write(path.join(appDir, "akan.config.ts"), "export default {};\n");
+    await write(path.join(appDir, "main.ts"), "export {};\n");
+    await write(path.join(appDir, "lib/post/post.abstract.md"), "# Post Abstract\n");
+    await write(path.join(appDir, "lib/post/post.constant.ts"), "export class Post {}\n");
+    await write(path.join(appDir, "lib/_payment/payment.abstract.md"), "# Payment Service Abstract\n");
+    await write(path.join(appDir, "lib/_payment/payment.service.ts"), "export const payment = {};\n");
+    await write(path.join(appDir, "lib/__scalar/money/money.abstract.md"), "# Money Scalar Abstract\n");
+    await write(path.join(appDir, "lib/__scalar/money/money.constant.ts"), "export class Money {}\n");
+
+    const workspace = WorkspaceExecutor.fromRoot({ workspaceRoot: root, repoName: "repo" });
+    const app = AppExecutor.from(workspace, appName);
+
+    await expect(app.scan({ write: false })).resolves.toBeDefined();
+  });
+});
+
 describe("getModelFileData", () => {
   test("reads model files and derives imported local, scalar, and lib models", async () => {
     const root = await makeTempRoot();

package/executors.test.ts

@@ -139,6 +139,10 @@ describe("Executor filesystem helpers", () => {
     expect(await readFile(path.join(root, "workspace/.gitignore"), "utf8")).toContain("node_modules");
     expect(await readFile(path.join(root, "workspace/.env"), "utf8")).toContain("AKAN_PUBLIC_REPO_NAME");
     expect(await readFile(path.join(root, "workspace/.vscode/settings.json"), "utf8")).toContain("typescript.tsdk");
+    expect(await readFile(path.join(root, "workspace/.cursor/rules/akan.mdc"), "utf8")).toContain(
+      "Akan.js Workspace Rules",
+    );
+    expect(await readFile(path.join(root, "workspace/AGENTS.md"), "utf8")).toContain("sample Agent Guide");
     expect(await readFile(path.join(root, "workspace/biome.json"), "utf8")).toContain(
       "./node_modules/@akanjs/devkit/lint/no-import-client-functions.grit",
     );

package/index.ts

@@ -1,6 +1,7 @@
 export * from "./aiEditor";
 export * from "./akanApp";
 export * from "./akanConfig";
+export * from "./akanContext";
 export * from "./applicationBuildReporter";
 export * from "./applicationBuildRunner";
 export * from "./applicationReleasePackager";

package/package.json

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

package/prompter.ts

@@ -11,10 +11,7 @@ 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);
@@ -28,14 +25,16 @@ export class Prompter {
 
   static async selectGuideline() {
     const guidelineRoot = await Prompter.#getGuidelineRoot();
-    const guideNames = (await fsPromise.readdir(guidelineRoot)).filter(
-      (name) => !name.startsWith("_"),
-    );
+    const guideNames = await Prompter.listGuidelines();
     return await select({
       message: "Select a guideline",
       choices: guideNames.map((name) => ({ name, value: name })),
     });
   }
+  static async listGuidelines() {
+    const guidelineRoot = await Prompter.#getGuidelineRoot();
+    return (await fsPromise.readdir(guidelineRoot)).filter((name) => !name.startsWith("_")).sort();
+  }
   static async getGuideJson(guideName: string): Promise<GuideGenerateJson> {
     const guidelineRoot = await Prompter.#getGuidelineRoot();
     const filePath = `${guidelineRoot}/${guideName}/${guideName}.generate.json`;

package/scanInfo.ts

@@ -99,6 +99,10 @@ const isAllowedLibRootFile = (filename: string) =>
   libRootAllowedFiles.has(filename) || rootSignalTestFilePattern.test(filename);
 const getScanPath = (exec: AppExecutor | LibExecutor, relativePath: string) =>
   path.posix.join(`${exec.type}s`, exec.name, relativePath.split(path.sep).join("/"));
+const getModuleNameFromPath = (kind: ModuleKind, modulePath: string) => {
+  const dirname = path.basename(modulePath);
+  return kind === "service" ? dirname.replace(/^_+/, "") : dirname;
+};
 
 async function assertScanConvention(exec: AppExecutor | LibExecutor, libRoot: { files: string[]; dirs: string[] }) {
   const violations: string[] = [];
@@ -158,6 +162,7 @@ async function validateModuleFiles(
   modulePath: string,
 ) {
   const { files, dirs } = await exec.getFilesAndDirs(modulePath);
+  const moduleName = getModuleNameFromPath(kind, modulePath);
   dirs.forEach((dirname) => {
     violations.push(`${getScanPath(exec, path.join(modulePath, dirname))}: unsupported module folder`);
   });
@@ -165,6 +170,7 @@ async function validateModuleFiles(
   files.forEach((filename) => {
     const filePath = path.join(modulePath, filename);
     if (filename === "index.ts" || filename === "index.tsx" || isAllowedTestFile(filename)) return;
+    if (filename === `${moduleName}.abstract.md`) return;
 
     const uiMatch = filename.match(/\.([A-Z][A-Za-z0-9]*)\.tsx$/);
     if (uiMatch) {
@@ -515,7 +521,7 @@ export class PkgInfo {
   readonly name: string;
   private scanResult: PkgScanResult;
 
-  static async getScanResult(exec: PkgExecutor) {
+  static async scanExecutor(exec: PkgExecutor) {
     const [tsconfig, rootPackageJson] = await Promise.all([exec.getTsConfig(), exec.workspace.getPackageJson()]);
     const scanner = await TypeScriptDependencyScanner.from(exec);
     const npmSet = new Set(Object.keys({ ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies }));
@@ -547,7 +553,7 @@ export class PkgInfo {
     const existingPkgInfo = PkgInfo.#pkgInfos.get(exec.name);
     if (existingPkgInfo && !options.refresh) return existingPkgInfo;
 
-    const scanResult = await PkgInfo.getScanResult(exec);
+    const scanResult = await PkgInfo.scanExecutor(exec);
     const pkgInfo = new PkgInfo(exec, scanResult);
     PkgInfo.#pkgInfos.set(exec.name, pkgInfo);
     return pkgInfo;