@akanjs/cli 3.0.0-alpha.9 → 3.0.0-alpha.91

package/index-pvb4vdwr.js

@@ -0,0 +1,159 @@
+// @bun
+import {
+  AppInfo
+} from "./index-q8sn827n.js";
+
+// pkgs/@akanjs/devkit/slicePlanner.ts
+class SlicePlanner {
+  static memberDirs = ["apps", "libs", "pkgs"];
+  static toolchainDependencies = [
+    "@akanjs/cli",
+    "@akanjs/devkit",
+    "@biomejs/biome",
+    "@types/bun",
+    "akanjs",
+    "tailwindcss",
+    "typescript"
+  ];
+  static akanPackages = ["akanjs", "@akanjs/devkit", "@akanjs/cli"];
+  static async#frameworkPeers(workspace) {
+    const peers = new Set;
+    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);
+        for (const peer of Object.keys(manifest.peerDependencies ?? {}))
+          peers.add(peer);
+        found = true;
+        break;
+      }
+    }
+    return found ? peers : null;
+  }
+  static typesPackageOf(dependency) {
+    return dependency.startsWith("@") ? `@types/${dependency.slice(1).replace("/", "__")}` : `@types/${dependency}`;
+  }
+  static async pruneDependencies(workspace, rootPackageJson, required) {
+    const peers = await SlicePlanner.#frameworkPeers(workspace);
+    const { workspaces: _workspaces, ...rest } = rootPackageJson;
+    if (!peers)
+      return {
+        packageJson: rest,
+        pruned: [],
+        warnings: [`dependencies carried whole \u2014 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) => Object.fromEntries(Object.entries(entries ?? {}).filter(([name]) => keep.has(name)));
+    const patched = rootPackageJson.patchedDependencies ?? {};
+    const packageJson = {
+      ...rest,
+      dependencies: pick(rootPackageJson.dependencies),
+      devDependencies: pick(rootPackageJson.devDependencies),
+      ...Object.keys(patched).length ? {
+        patchedDependencies: Object.fromEntries(Object.entries(patched).filter(([spec]) => keep.has(spec.slice(0, spec.lastIndexOf("@")))))
+      } : {}
+    };
+    const pruned = Object.keys({ ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies }).filter((name) => !keep.has(name)).sort();
+    return { packageJson, pruned, warnings: [] };
+  }
+  #app;
+  constructor(app) {
+    this.#app = app;
+  }
+  async#trackedFiles(paths) {
+    return await this.#app.workspace.listGitFiles(paths);
+  }
+  async#untrackedFiles(paths) {
+    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) {
+    return SlicePlanner.memberDirs.includes(file.split("/")[0] ?? "");
+  }
+  static #requiredDependencies(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) {
+    const patchedDependencies = packageJson.patchedDependencies ?? {};
+    const missing = (await Promise.all(Object.entries(patchedDependencies).map(async ([spec, patchPath]) => await this.#app.workspace.exists(patchPath) ? null : `${spec} -> ${patchPath}`))).filter((entry) => !!entry);
+    return missing.length ? [`patchedDependencies references a missing patch file: ${missing.join(", ")}`] : [];
+  }
+  async plan() {
+    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}`])])));
+    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 \u2014 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
+    };
+  }
+}
+var rootEntriesOf = (rootFiles) => [...new Set(rootFiles.map((file) => file.split("/")[0] ?? file))].sort();
+function formatSlicePlan(plan) {
+  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}) \u2014 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(`
+`);
+}
+
+export { SlicePlanner, formatSlicePlan };

package/{index-67546d0j.js → index-q0y2jq9j.js}

@@ -1,6 +1,6 @@
 // @bun
 // pkgs/@akanjs/devkit/fileSys.ts
-import { lstat, stat } from "fs/promises";
+import { lstat, rename, rm, stat } from "fs/promises";
 import { Logger } from "akanjs/common";
 
 class FileSys {
@@ -9,7 +9,7 @@ class FileSys {
     return await Bun.file(path).exists();
   }
   static async dirExists(path) {
-    return await stat(path).then((stat2) => stat2.isDirectory()).catch(() => false);
+    return await stat(path).then((stat) => stat.isDirectory()).catch(() => false);
   }
   static async exists(path) {
     return await stat(path).then(() => true).catch(() => false);
@@ -34,6 +34,18 @@ class FileSys {
   static async writeText(path, content) {
     return await Bun.file(path).write(content);
   }
+  static async writeTextAtomic(filePath, content) {
+    const temp = `${filePath}.${process.pid}.${Date.now().toString(36)}.tmp`;
+    try {
+      await Bun.write(temp, content);
+      await rename(temp, filePath);
+    } catch (error) {
+      await rm(temp, { force: true }).catch(() => {
+        return;
+      });
+      throw error;
+    }
+  }
   static async writeJson(path, content) {
     return await Bun.file(path).write(`${JSON.stringify(content, null, 2)}
 `);