@akanjs/devkit 3.0.0-alpha.8 → 3.0.0-alpha.81

package/scanInfo.ts

@@ -9,9 +9,9 @@ import type {
   PkgScanResult,
   ScanResult,
 } from "./akanConfig";
-
+import { AkanAppConfig } from "./akanConfig";
 import { AppExecutor, LibExecutor, PkgExecutor, WorkspaceExecutor } from "./executors";
-import { appRootAllowedDirs, appRootAllowedFiles, libFacetRootAllowedFiles } from "./workspaceLayout";
+import { isAllowedLibFacetRootFile, rootAllowedDirs, rootAllowedFiles } from "./workspaceLayout";
 
 const scalarFileTypes = ["constant", "dictionary", "document", "template", "unit", "util", "view", "zone"] as const;
 type ScalarFileType = (typeof scalarFileTypes)[number];
@@ -57,7 +57,6 @@ const moduleUiFileTypes = {
   scalar: new Set(["Template", "Unit"]),
 } satisfies Record<ModuleKind, Set<string>>;
 const testFilePattern = /\.(test|spec)\.(ts|tsx)$/;
-const rootSignalTestFilePattern = /^[A-Za-z][A-Za-z0-9_-]*\.signal\.(test|spec)\.(ts|tsx)$/;
 
 // The dependency scanner needs `typescript` (~65MB resident). Only the scan/sync commands run it, so
 // load it on demand rather than through the module graph of every process that imports scan info.
@@ -65,8 +64,6 @@ const createDependencyScanner = async (exec: AppExecutor | LibExecutor | PkgExec
   (await import("./dependencyScanner")).TypeScriptDependencyScanner.from(exec);
 
 const isAllowedTestFile = (filename: string) => testFilePattern.test(filename);
-const isAllowedLibRootFile = (filename: string) =>
-  libFacetRootAllowedFiles.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("/"));
 async function clearGeneratedRootCapacitorConfigs(exec: AppExecutor | LibExecutor) {
@@ -85,24 +82,29 @@ async function assertScanConvention(exec: AppExecutor | LibExecutor, libRoot: {
     violations.push(`${getScanPath(exec, relativePath)}: ${reason}`);
   };
 
-  if (exec.type === "app") {
-    const { files, dirs } = await exec.getFilesAndDirs(".");
-    files
-      .filter((filename) => !appRootAllowedFiles.has(filename))
-      .forEach((filename) => {
-        addViolation(filename, "unsupported app root file");
-      });
-    dirs
-      .filter((dirname) => !appRootAllowedDirs.has(dirname))
-      .forEach((dirname) => {
-        addViolation(dirname, "unsupported app root folder");
-      });
-  }
+  const allowedRootFiles: ReadonlySet<string> = rootAllowedFiles[exec.type];
+  const allowedRootDirs: ReadonlySet<string> = rootAllowedDirs[exec.type];
+  const { files, dirs } = await exec.getFilesAndDirs(".");
+  files
+    .filter((filename) => !allowedRootFiles.has(filename))
+    .forEach((filename) => {
+      addViolation(filename, `unsupported ${exec.type} root file`);
+    });
+  dirs
+    .filter((dirname) => !allowedRootDirs.has(dirname))
+    .forEach((dirname) => {
+      addViolation(dirname, `unsupported ${exec.type} root folder`);
+    });
+
+  //* An app validates its page tree in `getPageKeys`, which a lib has no equivalent of — so a lib's own
+  //* routes went unchecked until whichever app opted into them with `syncPageLibs` blew up on the sync.
+  if (exec.type === "lib")
+    for (const { relativePath, reason } of await exec.getPageConventionViolations()) addViolation(relativePath, reason);
 
   libRoot.files
-    .filter((filename) => !isAllowedLibRootFile(filename))
+    .filter((filename) => !isAllowedLibFacetRootFile(filename))
     .forEach((filename) => {
-      addViolation(path.join("lib", filename), "unsupported lib root file");
+      addViolation(path.join("lib", filename), "unsupported lib facet root file");
     });
 
   libRoot.dirs
@@ -284,12 +286,11 @@ class ScanInfo {
       }),
     ]);
     const routes = exec.type === "lib" ? [] : await (exec as AppExecutor).getPageKeys();
-    const scanResult: AppScanResult | LibScanResult = {
+    const common = {
       name: exec.name,
       type: exec.type,
       repoName: exec.workspace.repoName,
       serveDomain: WorkspaceExecutor.getBaseDevEnv(path.join(exec.workspace.workspaceRoot, ".env")).serveDomain,
-      akanConfig,
       files,
       libDeps,
       pkgDeps,
@@ -297,6 +298,11 @@ class ScanInfo {
       devDependencies: npmDevDeps.filter((dep) => !isAkanFrameworkDependency(dep)),
       routes,
     };
+    //? `exec.type` and the resolved config class are correlated, which the union alone cannot express.
+    const scanResult: AppScanResult | LibScanResult =
+      akanConfig instanceof AkanAppConfig
+        ? ({ ...common, akanConfig } satisfies AppScanResult)
+        : ({ ...common, akanConfig } satisfies LibScanResult);
     return scanResult;
   }
 
@@ -461,7 +467,7 @@ export class LibInfo extends ScanInfo {
           LibInfo.libInfos.set(libName, await LibInfo.fromExecutor(libExecutor));
         }),
     );
-    const libInfo = new LibInfo(exec, scanResult);
+    const libInfo = new LibInfo(exec, scanResult as LibScanResult);
     LibInfo.libInfos.set(exec.name, libInfo);
     LibInfo.#sortedLibIndices = null;
     return libInfo;
@@ -512,7 +518,7 @@ export class LibInfo extends ScanInfo {
 export class PkgInfo {
   readonly exec: PkgExecutor;
   readonly name: string;
-  private scanResult: PkgScanResult;
+  #scanResult: PkgScanResult;
 
   static async scanExecutor(exec: PkgExecutor) {
     const [tsconfig, rootPackageJson] = await Promise.all([exec.getTsConfig(), exec.workspace.getPackageJson()]);
@@ -554,10 +560,10 @@ export class PkgInfo {
   constructor(exec: PkgExecutor, scanResult: PkgScanResult) {
     this.exec = exec;
     this.name = exec.name;
-    this.scanResult = scanResult;
+    this.#scanResult = scanResult;
   }
   getScanResult() {
-    return this.scanResult;
+    return this.#scanResult;
   }
 }
 

package/semver.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, test } from "bun:test";
+import { compareSemver } from "./semver";
+
+describe("compareSemver", () => {
+  test("orders plain versions", () => {
+    expect(compareSemver("1.4.0", "1.3.13")).toBe(1);
+    expect(compareSemver("1.3.13", "1.4.0")).toBe(-1);
+    expect(compareSemver("19.2.7", "19.2.7")).toBe(0);
+  });
+
+  test("compares the version behind a range operator, not the range", () => {
+    expect(compareSemver("^3.1049.0", "^3.721.0")).toBe(1);
+    expect(compareSemver("~1.2.0", "^1.10.0")).toBe(-1);
+    expect(compareSemver(">=1.3.13", "1.4.0")).toBe(-1);
+  });
+
+  test("sorts a prerelease below its release", () => {
+    expect(compareSemver("1.0.0-alpha", "1.0.0")).toBe(-1);
+    expect(compareSemver("0.0.0-experimental-603e6108-20241029", "0.0.0")).toBe(-1);
+  });
+
+  test("falls back to numeric comparison for specs that are not versions", () => {
+    expect(compareSemver("workspace:*", "0.0.0")).toBe(0);
+    expect(compareSemver("workspace:*", "1.0.0")).toBe(-1);
+  });
+});

package/semver.ts

@@ -0,0 +1,31 @@
+// `Bun.semver.order` compares range strings loosely — `^3.1049.0` vs `^3.721.0` answers 0 — so the
+// operator prefix has to come off before it sees the version.
+const stripRangeOperator = (version: string) => version.replace(/^[\s^~>=<v]+/, "").trim();
+
+const parseVersion = (version: string): number[] => {
+  return version
+    .replace(/^[^\d]*/, "")
+    .split(/[.-]/)
+    .map((part) => Number.parseInt(part, 10))
+    .map((part) => (Number.isFinite(part) ? part : 0));
+};
+
+const compareNumeric = (a: string, b: string): number => {
+  const left = parseVersion(a);
+  const right = parseVersion(b);
+  const length = Math.max(left.length, right.length);
+  for (let i = 0; i < length; i++) {
+    const diff = (left[i] ?? 0) - (right[i] ?? 0);
+    if (diff !== 0) return diff > 0 ? 1 : -1;
+  }
+  return 0;
+};
+
+export const compareSemver = (a: string, b: string): number => {
+  try {
+    return Bun.semver.order(stripRangeOperator(a), stripRangeOperator(b));
+  } catch {
+    // Not every dependency spec is a version — `workspace:*`, a git URL, a tarball path.
+    return compareNumeric(a, b);
+  }
+};

package/slicePlanner.test.ts

@@ -0,0 +1,182 @@
+import { afterEach, beforeEach, 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 { AppExecutor, Executor, WorkspaceExecutor } from "./executors";
+import { formatSlicePlan, SlicePlanner } from "./slicePlanner";
+import type { PackageJson } from "./types";
+
+const tempRoots: string[] = [];
+const originalEnv = { ...process.env };
+
+beforeEach(() => {
+  process.env = { ...originalEnv };
+  process.env.AKAN_PUBLIC_REPO_NAME = "workspace";
+  process.env.AKAN_PUBLIC_SERVE_DOMAIN = "example.com";
+  process.env.AKAN_PUBLIC_ENV = "local";
+});
+
+afterEach(async () => {
+  process.env = { ...originalEnv };
+  await Promise.all(tempRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+
+const write = async (filePath: string, content: string) => {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, content);
+};
+
+const gitignore = [
+  "node_modules",
+  "apps/*/lib/cnst.ts",
+  "libs/*/common/index.ts",
+  "**/env.server.local.ts",
+  "**/akan.app.json",
+].join("\n");
+
+// `AppExecutor.from` and `AppInfo.fromExecutor` both memoise by name, so each fixture needs a fresh one.
+const makeWorkspace = async (appName: string, libName: string) => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "akan-slice-"));
+  tempRoots.push(root);
+  const rootPackageJson: PackageJson = {
+    name: "workspace",
+    version: "0.0.1",
+    description: "workspace",
+    workspaces: ["pkgs/*"],
+    dependencies: { lodash: "4.0.0", "unused-dep": "1.0.0", ioredis: "5.0.0" },
+    devDependencies: { typescript: "6.0.0", "@types/lodash": "4.1.0", "@types/qrcode": "1.0.0" },
+    patchedDependencies: {
+      "lodash@4.0.0": "patches/lodash@4.0.0.patch",
+      "unused-dep@1.0.0": "patches/unused-dep@1.0.0.patch",
+    },
+  };
+  await write(path.join(root, "package.json"), `${JSON.stringify(rootPackageJson, null, 2)}\n`);
+  await write(path.join(root, ".gitignore"), `${gitignore}\n`);
+  await write(path.join(root, "biome.json"), "{}\n");
+  //? The framework's peers are declared by akanjs, not by any import, so the planner reads them here.
+  await write(
+    path.join(root, "node_modules/akanjs/package.json"),
+    '{ "name": "akanjs", "version": "3.0.0", "peerDependencies": { "react": "19.0.0", "ioredis": "5.0.0" } }\n',
+  );
+  await write(path.join(root, "patches/lodash@4.0.0.patch"), "");
+  await write(path.join(root, "patches/unused-dep@1.0.0.patch"), "");
+
+  await write(path.join(root, `apps/${appName}/akan.config.ts`), "export default {};\n");
+  await write(path.join(root, `apps/${appName}/tsconfig.json`), "{}\n");
+  await write(
+    path.join(root, `apps/${appName}/lib/task/task.constant.ts`),
+    [
+      `import { helper } from "@libs/${libName}/common";`,
+      'import lodash from "lodash";',
+      "",
+      "export { helper, lodash };",
+      "",
+    ].join("\n"),
+  );
+  await write(path.join(root, `apps/${appName}/lib/cnst.ts`), "export {};\n");
+  await write(path.join(root, `apps/${appName}/env/env.server.local.ts`), "export const env = {};\n");
+
+  await write(path.join(root, `libs/${libName}/akan.config.ts`), "export default {};\n");
+  await write(path.join(root, `libs/${libName}/tsconfig.json`), "{}\n");
+  await mkdir(path.join(root, `libs/${libName}/lib`), { recursive: true });
+  await write(path.join(root, `libs/${libName}/common/helper.ts`), "export const helper = 1;\n");
+  await write(path.join(root, `libs/${libName}/common/index.ts`), 'export * from "./helper";\n');
+
+  await write(path.join(root, "pkgs/in-tree/package.json"), '{ "name": "in-tree" }\n');
+
+  const git = new Executor("fixture", root);
+  await git.spawn("git", ["init", "--quiet"]);
+  await git.spawn("git", ["add", "-A"]);
+  await git.spawn("git", ["-c", "user.email=t@t", "-c", "user.name=t", "commit", "--quiet", "-m", "fixture"]);
+
+  const workspace = WorkspaceExecutor.fromRoot({ workspaceRoot: root, repoName: `workspace-${appName}` });
+  return { root, plan: async () => await new SlicePlanner(AppExecutor.from(workspace, appName)).plan() };
+};
+
+describe("SlicePlanner", () => {
+  test("resolves the lib closure and lists only git-tracked slice files", async () => {
+    const { plan } = await makeWorkspace("slice-app", "slice-lib");
+    const result = await plan();
+
+    expect(result.app).toBe("slice-app");
+    expect(result.libs).toEqual(["slice-lib"]);
+    expect(result.appFiles).toContain("apps/slice-app/lib/task/task.constant.ts");
+    expect(result.libFiles["slice-lib"]).toContain("libs/slice-lib/common/helper.ts");
+  });
+
+  test("leaves out generated barrels, env values and every other workspace member", async () => {
+    const { plan } = await makeWorkspace("ignore-app", "ignore-lib");
+    const result = await plan();
+
+    expect(result.appFiles).not.toContain("apps/ignore-app/lib/cnst.ts");
+    expect(result.appFiles).not.toContain("apps/ignore-app/env/env.server.local.ts");
+    expect(result.libFiles["ignore-lib"]).not.toContain("libs/ignore-lib/common/index.ts");
+    expect(result.rootFiles).toEqual(expect.arrayContaining(["package.json", ".gitignore", "biome.json"]));
+    expect(result.rootFiles.filter((file) => file.startsWith("pkgs/"))).toEqual([]);
+    expect(result.rootFiles.filter((file) => /^(apps|libs)\//.test(file))).toEqual([]);
+  });
+
+  test("drops `workspaces` from the slice manifest and reports it", async () => {
+    const { plan } = await makeWorkspace("manifest-app", "manifest-lib");
+    const result = await plan();
+
+    expect(result.packageJson.workspaces).toBeUndefined();
+    expect(result.warnings.join("\n")).toContain("workspaces");
+  });
+
+  test("prunes what the slice does not import, keeping the toolchain and the type packages", async () => {
+    const { plan } = await makeWorkspace("deps-app", "deps-lib");
+    const result = await plan();
+
+    expect(result.requiredDependencies).toContain("lodash");
+    //? `ioredis` is an akanjs peer: nothing imports it, and pruning it would break the server at runtime.
+    expect(result.packageJson.dependencies).toEqual({ lodash: "4.0.0", ioredis: "5.0.0" });
+    //? Nothing imports `@types/lodash` by name, so only its companion keeps it.
+    expect(result.packageJson.devDependencies).toEqual({ typescript: "6.0.0", "@types/lodash": "4.1.0" });
+    expect(result.packageJson.patchedDependencies).toEqual({ "lodash@4.0.0": "patches/lodash@4.0.0.patch" });
+    expect(result.unusedDependencies).toEqual(["@types/qrcode", "unused-dep"]);
+  });
+
+  test("carries the dependencies whole when there is no akanjs manifest to read the peers from", async () => {
+    const { root, plan } = await makeWorkspace("nopeer-app", "nopeer-lib");
+    await rm(path.join(root, "node_modules"), { recursive: true, force: true });
+    const result = await plan();
+
+    expect(result.unusedDependencies).toEqual([]);
+    expect(result.packageJson.dependencies).toEqual({ lodash: "4.0.0", "unused-dep": "1.0.0", ioredis: "5.0.0" });
+    expect(result.warnings.join("\n")).toContain("carried whole");
+  });
+
+  test("names a type package the way DefinitelyTyped does", () => {
+    expect(SlicePlanner.typesPackageOf("lodash")).toBe("@types/lodash");
+    expect(SlicePlanner.typesPackageOf("@capacitor/core")).toBe("@types/capacitor__core");
+  });
+
+  test("warns about untracked files under the slice paths", async () => {
+    const { root, plan } = await makeWorkspace("untracked-app", "untracked-lib");
+    await write(path.join(root, "apps/untracked-app/lib/task/task.service.ts"), "export {};\n");
+    const result = await plan();
+
+    expect(result.warnings.join("\n")).toContain("apps/untracked-app/lib/task/task.service.ts");
+  });
+});
+
+describe("formatSlicePlan", () => {
+  test("collapses the workspace shell to its top-level entries", () => {
+    const text = formatSlicePlan({
+      app: "demo",
+      libs: ["util"],
+      appFiles: ["apps/demo/main.ts"],
+      libFiles: { util: ["libs/util/index.ts"] },
+      rootFiles: ["package.json", "infra/app/values/main.yaml", "infra/app/templates/app.yaml"],
+      packageJson: { name: "demo", version: "0.0.1", description: "demo" },
+      requiredDependencies: [],
+      unusedDependencies: [],
+      warnings: [],
+    });
+
+    expect(text).toContain("app: demo (apps/demo: 1 files)");
+    expect(text).toContain("3 files across infra, package.json");
+    expect(text).toContain("(none)");
+  });
+});

package/slicePlanner.ts

@@ -0,0 +1,235 @@
+import type { AppExecutor, WorkspaceExecutor } from "./executors";
+import { AppInfo } from "./scanInfo";
+import type { PackageJson } from "./types";
+
+export interface SlicePlan {
+  app: string;
+  /** Transitive lib closure, in mount order. */
+  libs: string[];
+  appFiles: string[];
+  libFiles: Record<string, string[]>;
+  rootFiles: string[];
+  /** Root manifest for a workspace holding only this slice, with the dependencies it does not use pruned. */
+  packageJson: PackageJson;
+  /** What this slice imports, so a caller serving several apps can union them before pruning. */
+  requiredDependencies: string[];
+  /** Root dependencies nothing in the slice imports — left out of `packageJson`. */
+  unusedDependencies: string[];
+  warnings: string[];
+}
+
+/**
+ * The exact file set a single app needs to live in a workspace of its own: the app, its transitive lib
+ * closure, the workspace shell around them, and a root manifest for the result.
+ *
+ * Consumed by `akan plan-slice`, and by anything that moves an app or a lib between workspaces.
+ */
+export class SlicePlanner {
+  /** Root entries owned by an app, a lib or an in-tree package rather than by the workspace shell. */
+  static readonly memberDirs = ["apps", "libs", "pkgs"];
+  /** Never pruned: the toolchain a workspace runs on, which no source file imports. */
+  static readonly toolchainDependencies = [
+    "@akanjs/cli",
+    "@akanjs/devkit",
+    "@biomejs/biome",
+    "@types/bun",
+    "akanjs",
+    "tailwindcss",
+    "typescript",
+  ];
+  static readonly akanPackages = ["akanjs", "@akanjs/devkit", "@akanjs/cli"];
+
+  /**
+   * What the framework imports but does not install, so a workspace root has to declare it: `react`,
+   * `scheduler` and the RSC runtime, but also `ioredis`, `postgres` and `bullmq` the moment an app uses
+   * a database or a queue. No source file in the workspace names any of them, so no scan can find them
+   * — they are the akan packages' own `peerDependencies`, read wherever those are installed. Anything
+   * they declare as a plain dependency is installed with them and needs no root entry.
+   */
+  static async #frameworkPeers(workspace: WorkspaceExecutor) {
+    const peers = new Set<string>();
+    let found = false;
+    for (const akanPackage of SlicePlanner.akanPackages) {
+      for (const prefix of ["node_modules", "pkgs"]) {
+        const manifestPath = `${prefix}/${akanPackage}/package.json`;
+        if (!(await workspace.exists(manifestPath))) continue;
+        const manifest = (await workspace.readJson(manifestPath)) as PackageJson;
+        for (const peer of Object.keys(manifest.peerDependencies ?? {})) peers.add(peer);
+        found = true;
+        break;
+      }
+    }
+    return found ? peers : null;
+  }
+
+  /** DefinitelyTyped's name for a package: `lodash` -> `@types/lodash`, `@scope/x` -> `@types/scope__x`. */
+  static typesPackageOf(dependency: string) {
+    return dependency.startsWith("@") ? `@types/${dependency.slice(1).replace("/", "__")}` : `@types/${dependency}`;
+  }
+
+  /**
+   * The root manifest a workspace holding only these dependencies would carry, with the workspace's own
+   * version specs kept — that is what makes one branch resolve to one dependency tree everywhere.
+   *
+   * A `@types/x` package is kept alongside `x`: nothing imports it by name, so no scan can see it, and
+   * dropping it breaks the typecheck of every file that imports `x`. `workspaces` is dropped because it
+   * names in-tree packages, which a slice never carries — it consumes akanjs from the registry.
+   */
+  static async pruneDependencies(
+    workspace: WorkspaceExecutor,
+    rootPackageJson: PackageJson,
+    required: Iterable<string>,
+  ) {
+    const peers = await SlicePlanner.#frameworkPeers(workspace);
+    const { workspaces: _workspaces, ...rest } = rootPackageJson;
+    //* Without akanjs's peer list every peer looks unused, and pruning it produces an install that
+    //* succeeds and a server that fails at its first redis or postgres call. Carry the dependencies
+    //* whole instead and say why.
+    if (!peers)
+      return {
+        packageJson: rest as PackageJson,
+        pruned: [],
+        warnings: [`dependencies carried whole — none of ${SlicePlanner.akanPackages.join(", ")} is installed`],
+      };
+    const keep = new Set([...SlicePlanner.toolchainDependencies, ...peers, ...required]);
+    for (const dependency of [...keep]) keep.add(SlicePlanner.typesPackageOf(dependency));
+    const pick = (entries: Record<string, string> | undefined) =>
+      Object.fromEntries(Object.entries(entries ?? {}).filter(([name]) => keep.has(name)));
+    const patched = (rootPackageJson.patchedDependencies ?? {}) as Record<string, string>;
+    const packageJson = {
+      ...rest,
+      dependencies: pick(rootPackageJson.dependencies),
+      devDependencies: pick(rootPackageJson.devDependencies),
+      //? A key here is `name@version`, and bun fails the install when a patch names a package the
+      //? manifest no longer asks for.
+      ...(Object.keys(patched).length
+        ? {
+            patchedDependencies: Object.fromEntries(
+              Object.entries(patched).filter(([spec]) => keep.has(spec.slice(0, spec.lastIndexOf("@")))),
+            ),
+          }
+        : {}),
+    } as PackageJson;
+    const pruned = Object.keys({ ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies })
+      .filter((name) => !keep.has(name))
+      .sort();
+    return { packageJson, pruned, warnings: [] as string[] };
+  }
+
+  #app: AppExecutor;
+  constructor(app: AppExecutor) {
+    this.#app = app;
+  }
+
+  async #trackedFiles(paths: string[]) {
+    return await this.#app.workspace.listGitFiles(paths);
+  }
+
+  async #untrackedFiles(paths: string[]) {
+    const [tracked, all] = await Promise.all([
+      this.#app.workspace.listGitFiles(paths),
+      this.#app.workspace.listGitFiles(paths, { untracked: true }),
+    ]);
+    const trackedSet = new Set(tracked);
+    return all.filter((file) => !trackedSet.has(file));
+  }
+
+  #isMemberFile(file: string) {
+    return SlicePlanner.memberDirs.includes(file.split("/")[0] ?? "");
+  }
+
+  static #requiredDependencies(appInfo: AppInfo) {
+    const scanResults = [
+      appInfo.getScanResult(),
+      ...[...appInfo.getLibInfos().values()].map((lib) => lib.getScanResult()),
+    ];
+    return new Set([
+      ...scanResults.flatMap((scanResult) => [
+        ...scanResult.dependencies,
+        ...scanResult.devDependencies,
+        ...scanResult.pkgDeps,
+      ]),
+    ]);
+  }
+
+  async #patchWarnings(packageJson: PackageJson) {
+    const patchedDependencies = (packageJson.patchedDependencies ?? {}) as Record<string, string>;
+    const missing = (
+      await Promise.all(
+        Object.entries(patchedDependencies).map(async ([spec, patchPath]) =>
+          (await this.#app.workspace.exists(patchPath)) ? null : `${spec} -> ${patchPath}`,
+        ),
+      )
+    ).filter((entry): entry is string => !!entry);
+    return missing.length ? [`patchedDependencies references a missing patch file: ${missing.join(", ")}`] : [];
+  }
+
+  async plan(): Promise<SlicePlan> {
+    const appInfo = await AppInfo.fromExecutor(this.#app);
+    const libs = appInfo.getLibs();
+    const slicePaths = [`apps/${this.#app.name}`, ...libs.map((lib) => `libs/${lib}`)];
+
+    const [appFiles, allTracked, untracked, rootPackageJson] = await Promise.all([
+      this.#trackedFiles([`apps/${this.#app.name}`]),
+      this.#trackedFiles(["."]),
+      this.#untrackedFiles(slicePaths),
+      this.#app.workspace.getPackageJson(),
+    ]);
+
+    const libFiles = Object.fromEntries(
+      await Promise.all(libs.map(async (lib) => [lib, await this.#trackedFiles([`libs/${lib}`])] as const)),
+    );
+    const rootFiles = allTracked.filter((file) => !this.#isMemberFile(file));
+
+    const required = SlicePlanner.#requiredDependencies(appInfo);
+    const {
+      packageJson,
+      pruned,
+      warnings: manifestWarnings,
+    } = await SlicePlanner.pruneDependencies(this.#app.workspace, rootPackageJson, required);
+
+    const warnings = [
+      ...(untracked.length
+        ? [`${untracked.length} untracked file(s) under the slice paths: ${untracked.join(", ")}`]
+        : []),
+      ...(rootPackageJson.workspaces ? ["root `workspaces` dropped — a slice consumes akanjs from the registry"] : []),
+      ...manifestWarnings,
+      ...(await this.#patchWarnings(rootPackageJson)),
+    ];
+
+    return {
+      app: this.#app.name,
+      libs,
+      appFiles,
+      libFiles,
+      rootFiles,
+      packageJson,
+      requiredDependencies: [...required].sort(),
+      unusedDependencies: pruned,
+      warnings,
+    };
+  }
+}
+
+/** Top-level entry each path sits under, so a long tree (`infra/**`) reads as one line. */
+const rootEntriesOf = (rootFiles: string[]) => [...new Set(rootFiles.map((file) => file.split("/")[0] ?? file))].sort();
+
+export function formatSlicePlan(plan: SlicePlan) {
+  const libCounts = Object.entries(plan.libFiles).map(([lib, files]) => `  - libs/${lib}: ${files.length} files`);
+  const sections = [
+    "Akan Slice Plan",
+    `app: ${plan.app} (apps/${plan.app}: ${plan.appFiles.length} files)`,
+    `libs: ${plan.libs.length ? plan.libs.join(", ") : "(none)"}`,
+    ...libCounts,
+    `workspace shell: ${plan.rootFiles.length} files across ${rootEntriesOf(plan.rootFiles).join(", ")}`,
+    "",
+    `Root dependencies this slice does not use (${plan.unusedDependencies.length}) — pruned:`,
+    "",
+    ...(plan.unusedDependencies.length ? plan.unusedDependencies.map((dep) => `  - ${dep}`) : ["  (none)"]),
+    "",
+    `Warnings (${plan.warnings.length}):`,
+    "",
+    ...(plan.warnings.length ? plan.warnings.map((warning) => `  - ${warning}`) : ["  (none)"]),
+  ];
+  return sections.join("\n");
+}