@akanjs/cli 3.0.0-alpha.11 → 3.0.0-alpha.111

package/{index-nwqqssnb.js → index-aj7tyh5w.js}

@@ -1,20 +1,20 @@
 // @bun
 import {
-  AiSession,
-  CloudApi,
+  getDefaultHostConfig,
   GlobalConfig,
-  getDefaultHostConfig
-} from "./index-0cj2zxbm.js";
+  CloudApi,
+  AiSession
+} from "./index-kn1h7p1x.js";
 import {
-  openBrowser
-} from "./index-bzznxgcx.js";
+  WorkspaceExecutor,
+  AppExecutor
+} from "./index-2tv3fdx4.js";
 import {
   runner
-} from "./index-etwh7sd3.js";
+} from "./index-mak3cd28.js";
 import {
-  AppExecutor,
-  WorkspaceExecutor
-} from "./index-yzsxc30b.js";
+  openBrowser
+} from "./index-v0qh106m.js";
 
 // pkgs/@akanjs/cli/npmRegistry.ts
 var defaultNpmRegistry = "https://registry.npmjs.org";
@@ -98,8 +98,8 @@ class CloudRunner extends runner("cloud") {
     const selectedName = await select({
       message: "Select the remote env server",
       choices: [
-        ...serverEntries.map(([name, config2]) => ({
-          name: `${name} (${config2.username ? `${config2.username}@` : ""}${config2.host}${config2.port ? `:${config2.port}` : ""})`,
+        ...serverEntries.map(([name, config]) => ({
+          name: `${name} (${config.username ? `${config.username}@` : ""}${config.host}${config.port ? `:${config.port}` : ""})`,
           value: name
         })),
         { name: "Add new remote server", value: addRemoteEnvServerValue },
@@ -203,12 +203,12 @@ ${chalk.green("\u27A4")} Authentication Required`));
     const MAX_RETRY = 300;
     for (let i = 0;i < MAX_RETRY; i++) {
       const accessToken = await cloudApi.getRemoteAuthToken(remoteId);
-      const self2 = await cloudApi.getRemoteSelf();
-      if (accessToken && self2) {
-        await GlobalConfig.setHostConfig({ host: config.host, auth: { accessToken, self: self2 } });
+      const self = await cloudApi.getRemoteSelf();
+      if (accessToken && self) {
+        await GlobalConfig.setHostConfig({ host: config.host, auth: { accessToken, self } });
         Logger.rawLog(chalk.green(`\r\u2713 Authentication successful!`));
         Logger.rawLog(chalk.green.bold(`
-\u2728 Welcome aboard, ${self2.nickname ?? "anonymous"}!`));
+\u2728 Welcome aboard, ${self.nickname ?? "anonymous"}!`));
         Logger.rawLog(chalk.dim(`You're now ready to use Akan CLI!
 `));
         return true;
@@ -253,12 +253,12 @@ ${chalk.green("\u27A4")} Authentication Required`));
     const isOfficialRelease = !devPatchVersion;
     const targetVersionPrefix = isOfficialRelease ? `${majorVersion}.${minorVersion}` : `${majorVersion}.${minorVersion}.${patchVersion}`;
     const tag = distTag ?? (isOfficialRelease ? "latest" : patchVersion.split("-").at(1) ?? "dev");
-    const getNextVersion = async (prefix, tag2) => {
+    const getNextVersion = async (prefix, tag) => {
       try {
-        const latestPublishedVersion2 = await getLatestPackageVersion("akanjs", tag2, registry);
-        const latestPatch = latestPublishedVersion2.startsWith(prefix) ? parseInt(latestPublishedVersion2.split(".").at(-1) ?? "-1") : -1;
-        const nextVersion2 = `${prefix}.${latestPatch + 1}`;
-        return { nextVersion: nextVersion2, latestPublishedVersion: latestPublishedVersion2 };
+        const latestPublishedVersion = await getLatestPackageVersion("akanjs", tag, registry);
+        const latestPatch = latestPublishedVersion.startsWith(prefix) ? parseInt(latestPublishedVersion.split(".").at(-1) ?? "-1") : -1;
+        const nextVersion = `${prefix}.${latestPatch + 1}`;
+        return { nextVersion, latestPublishedVersion };
       } catch {
         return { nextVersion: `${prefix}.0`, latestPublishedVersion: null };
       }
@@ -283,7 +283,10 @@ ${chalk.green("\u27A4")} Authentication Required`));
         return;
       }
     }
-    await Promise.all(akanPkgs.map(async (library) => {
+    Logger.info("Logging in to npm...");
+    await workspace.spawn("npm", ["login"], { stdio: "inherit" });
+    Logger.info("Logged in to npm");
+    for (const library of akanPkgs) {
       Logger.info(`Publishing ${library}@${nextVersion} to ${registry ?? "npm"}...`);
       await workspace.spawn("npm", ["publish", "--tag", tag, ...this.#getRegistryArgs(registry), ...this.#getLocalRegistryAuthArgs(registry)], {
         cwd: path.join(workspace.workspaceRoot, "dist/pkgs", library),
@@ -291,7 +294,7 @@ ${chalk.green("\u27A4")} Authentication Required`));
         stdio: "inherit"
       });
       Logger.info(`${library}@${nextVersion} is published to ${registry ?? "npm"}`);
-    }));
+    }
     Logger.info(`All libraries are published to ${registry ?? "npm"}`);
   }
   async update(workspace, tag = "latest", { registryUrl } = {}) {

package/{index-xys926f2.js → index-by5gpp8x.js}

@@ -2,7 +2,7 @@
 // pkgs/@akanjs/devkit/recipeScanner.ts
 import { readdir } from "fs/promises";
 import ts from "typescript";
-var collectRecipeSources = async (uiDirPath, importFrom, basename = "Recipe") => {
+var collectRecipeSources2 = async (uiDirPath, importFrom, basename = "Recipe") => {
   const read = async (filePath) => {
     const content = await Bun.file(filePath).text().catch(() => "");
     return content ? { path: filePath, content, importFrom } : null;
@@ -12,7 +12,7 @@ var collectRecipeSources = async (uiDirPath, importFrom, basename = "Recipe") =>
   const fromDir = await Promise.all(dirEntries.filter((entry) => entry.endsWith(".ts") && entry !== "index.ts" && !/\.(test|spec)\.ts$/.test(entry)).sort().map((entry) => read(`${uiDirPath}/${basename}/${entry}`)));
   return [flat, ...fromDir].filter((source) => !!source);
 };
-var scanRecipes = (sources) => {
+var scanRecipes2 = (sources) => {
   const recipes = [];
   for (const source of sources) {
     const sourceFile = ts.createSourceFile(source.path, source.content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
@@ -87,7 +87,7 @@ var isNamed = (name) => ts.isIdentifier(name) || ts.isStringLiteral(name);
 var propName = (name) => name.text;
 var DUPLICATE_TOKEN_RATIO = 0.7;
 var MIN_FINGERPRINT_TOKENS = 3;
-var findInlineRecipeDuplicates = (recipes, files) => {
+var findInlineRecipeDuplicates2 = (recipes, files) => {
   const fingerprints = recipes.map((recipe) => ({ recipe: recipe.name, tokens: (recipe.base ?? "").split(/\s+/).filter(Boolean) })).filter((fingerprint) => fingerprint.tokens.length >= MIN_FINGERPRINT_TOKENS).map((fingerprint) => ({ ...fingerprint, needed: Math.ceil(fingerprint.tokens.length * DUPLICATE_TOKEN_RATIO) }));
   if (fingerprints.length === 0)
     return [];
@@ -133,4 +133,4 @@ var getLeadingDoc = (fullText, node) => {
   return line || undefined;
 };
 
-export { collectRecipeSources, scanRecipes, findInlineRecipeDuplicates };
+export { collectRecipeSources2, scanRecipes2, findInlineRecipeDuplicates2 };

package/{index-yzmqvg23.js → index-fz5q3gd7.js}

@@ -1,17 +1,17 @@
 // @bun
 import {
-  AkanContextAnalyzer
-} from "./index-e4b2ae6b.js";
-import {
-  createRepairReport,
+  writeWorkflowRunArtifact,
   generatedFilePathsForTarget,
-  renderRepairReport,
   writeGeneratedSyncState,
-  writeWorkflowRunArtifact
-} from "./index-kcsa1zff.js";
+  createRepairReport,
+  renderRepairReport
+} from "./index-gyd220p2.js";
+import {
+  AkanContextAnalyzer
+} from "./index-ktb5njgy.js";
 import {
   runner
-} from "./index-etwh7sd3.js";
+} from "./index-mak3cd28.js";
 
 // pkgs/@akanjs/cli/repair/repair.runner.ts
 var commandForShell = (command) => command.startsWith("akan ") ? `bun run ${command}` : command;

package/{index-kcsa1zff.js → index-gyd220p2.js}

@@ -2,7 +2,7 @@
 import {
   AppExecutor,
   LibExecutor
-} from "./index-yzsxc30b.js";
+} from "./index-2tv3fdx4.js";
 
 // pkgs/@akanjs/devkit/workflow/utils.ts
 var jsonText = (value, { trailingNewline = true } = {}) => `${JSON.stringify(value, null, 2)}${trailingNewline ? `
@@ -914,9 +914,9 @@ ${options.closingIndent}}`);
   const beforeField = locator.fields[insertIndex];
   if (beforeField) {
     const leadingComments = ts.getLeadingCommentRanges(content, beforeField.fullStart) ?? [];
-    const insertAt2 = lineStartAt(content, leadingComments[0]?.pos ?? beforeField.start);
-    const indent2 = lineIndentAt(content, beforeField.start) || options.fieldIndent;
-    return spliceText(content, insertAt2, insertAt2, `${indent2}${formattedLine}
+    const insertAt = lineStartAt(content, leadingComments[0]?.pos ?? beforeField.start);
+    const indent = lineIndentAt(content, beforeField.start) || options.fieldIndent;
+    return spliceText(content, insertAt, insertAt, `${indent}${formattedLine}
 `);
   }
   const afterField = locator.fields[locator.fields.length - 1];

package/{index-j37qq1f2.js → index-h7yw2z9n.js}

@@ -1,14 +1,14 @@
 // @bun
 import {
-  getDirname
-} from "./index-1577bej2.js";
+  getDirname2
+} from "./index-6wwzs1bc.js";
 
 // pkgs/@akanjs/devkit/prompter.ts
 import fsPromise from "fs/promises";
 import { input, select } from "@inquirer/prompts";
 class Prompter {
   static async#getGuidelineRoot() {
-    const dirname = getDirname(import.meta.url);
+    const dirname = getDirname2(import.meta.url);
     const candidates = [`${dirname}/guidelines`, `${dirname}/../cli/guidelines`];
     for (const candidate of candidates) {
       try {
@@ -19,7 +19,6 @@ class Prompter {
     return candidates[0];
   }
   static async selectGuideline() {
-    const guidelineRoot = await Prompter.#getGuidelineRoot();
     const guideNames = await Prompter.listGuidelines();
     return await select({
       message: "Select a guideline",
@@ -37,10 +36,11 @@ class Prompter {
     return JSON.parse(guideJson);
   }
   static async getInstruction(guideName) {
+    const guideNames = await Prompter.listGuidelines();
+    if (!guideNames.includes(guideName))
+      throw new Error(`Unknown guideline "${guideName}". Available: ${guideNames.join(", ")}`);
     const guidelineRoot = await Prompter.#getGuidelineRoot();
-    const filePath = `${guidelineRoot}/${guideName}/${guideName}.instruction.md`;
-    const content = await fsPromise.readFile(filePath, "utf-8");
-    return content;
+    return await fsPromise.readFile(`${guidelineRoot}/${guideName}/${guideName}.instruction.md`, "utf-8");
   }
   static async getUpdateRequest(guideName) {
     return await input({

package/{index-bjpxzr6s.js → index-hwkygn9s.js}

@@ -422,7 +422,7 @@ class HmrWatcher {
     this.#unreportedChanges += unreported;
     if (!this.#reportedCompensating) {
       this.#reportedCompensating = true;
-      this.#logger.info(`[hmr] recovered ${unreported} change(s) that fs.watch did not report; Bun coalesces concurrent saves and drops all but one, so changes are resolved by mtime`);
+      this.#logger.verbose(`[hmr] recovered ${unreported} change(s) that fs.watch did not report; Bun coalesces concurrent saves and drops all but one, so changes are resolved by mtime`);
     }
     this.#logger.verbose(`[hmr] mtime scan found ${unreported} change(s) fs.watch never reported (${this.#unreportedChanges} total)`);
   }
@@ -463,6 +463,7 @@ class HmrWatcher {
 
 // pkgs/@akanjs/devkit/frontendBuild/watchRootResolver.ts
 import fs2 from "fs";
+import { readFile } from "fs/promises";
 import path4 from "path";
 
 class WatchRootResolver {
@@ -472,6 +473,10 @@ class WatchRootResolver {
   }
   async resolve() {
     const tsconfig = await this.#app.getTsConfig();
+    const appDir = path4.resolve(this.#app.cwdPath);
+    const appsContainer = path4.dirname(appDir);
+    const libsContainer = path4.resolve(this.#app.workspace.workspaceRoot, "libs");
+    const libRoots = await this.#resolveLibRoots(libsContainer);
     const set = new Set;
     set.add(path4.resolve(`${this.#app.cwdPath}/page`));
     for (const targets of Object.values(tsconfig.compilerOptions.paths ?? {})) {
@@ -482,12 +487,55 @@ class WatchRootResolver {
           continue;
         const cleaned = target.replace(/\/?\*+.*$/, "").replace(/\/[^/]+\.[^/]+$/, "");
         const resolved = path4.resolve(this.#app.workspace.workspaceRoot, cleaned);
-        if (fs2.existsSync(resolved))
-          set.add(resolved);
+        if (resolved === libsContainer && libRoots) {
+          for (const root of libRoots)
+            set.add(root);
+          continue;
+        }
+        const root = resolved === appsContainer ? appDir : resolved;
+        if (fs2.existsSync(root))
+          set.add(root);
       }
     }
     return [...set];
   }
+  async#resolveLibRoots(libsContainer) {
+    const libDeps = await this.#resolveLibDeps(libsContainer);
+    if (!libDeps)
+      return null;
+    return libDeps.map((name) => path4.join(libsContainer, name)).filter((dir) => fs2.existsSync(dir));
+  }
+  async#resolveLibDeps(libsContainer) {
+    const scanInfo = this.#app.getScanInfo({ allowEmpty: true });
+    if (scanInfo?.type === "app")
+      return scanInfo.libDeps;
+    const direct = await WatchRootResolver.#readManifestLibDeps(path4.join(this.#app.cwdPath, "akan.app.json"));
+    if (!direct)
+      return null;
+    const closure = new Set;
+    const queue = [...direct];
+    while (queue.length > 0) {
+      const name = queue.shift();
+      if (!name || closure.has(name))
+        continue;
+      closure.add(name);
+      const nested = await WatchRootResolver.#readManifestLibDeps(path4.join(libsContainer, name, "akan.lib.json"));
+      if (!nested)
+        return null;
+      queue.push(...nested);
+    }
+    return [...closure];
+  }
+  static async#readManifestLibDeps(manifestPath) {
+    try {
+      const parsed = JSON.parse(await readFile(manifestPath, "utf8"));
+      if (!Array.isArray(parsed.libDeps))
+        return null;
+      return parsed.libDeps.filter((name) => typeof name === "string" && name.length > 0);
+    } catch {
+      return null;
+    }
+  }
 }
 
 export { HmrWatcher, WatchRootResolver };

package/index-j9yhg404.js

@@ -0,0 +1,159 @@
+// @bun
+import {
+  AppInfo
+} from "./index-2tv3fdx4.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-46tjzh6s.js → index-kcxmv48c.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   FileSys
-} from "./index-67546d0j.js";
+} from "./index-q0y2jq9j.js";
 
 // pkgs/@akanjs/devkit/dependencyScanner.ts
 import { builtinModules } from "module";
@@ -9,39 +9,41 @@ import * as path from "path";
 import ignore from "ignore";
 import ts from "typescript";
 var testFileRegex = /\.(?:test|spec)\.[cm]?[tj]sx?$/;
+var skipDirs = ["node_modules", "dist", "build", ".git", ".next", "public", "ios", "android", "__fixtures__"];
+var isSkippedPath = (filePath) => skipDirs.some((dir) => filePath.includes(`/${dir}/`) || filePath.startsWith(`${dir}/`));
 var builtinModuleSet = new Set([...builtinModules, ...builtinModules.map((mod) => `node:${mod}`)]);
 var stripShebang = (source) => source.replace(/^#!.*(?:\r?\n|$)/, "");
 
-class TypeScriptDependencyScanner {
+class TypeScriptDependencyScanner2 {
   #fileDependencies = new Map;
   #fileRuntimeDependencies = new Map;
   #fileTypeDependencies = new Map;
   #visitedFiles = new Set;
   #tsTranspiler = new Bun.Transpiler({ loader: "ts" });
   #tsxTranspiler = new Bun.Transpiler({ loader: "tsx" });
-  directory;
-  rootPackageJson;
-  ig;
-  workspaceRoot;
+  #directory;
+  #rootPackageJson;
+  #ig;
+  #workspaceRoot;
   constructor(directory, {
     workspaceRoot,
     rootPackageJson,
     gitignorePatterns = []
   }) {
-    this.directory = directory;
-    this.rootPackageJson = rootPackageJson;
-    this.ig = ignore().add(gitignorePatterns);
-    this.workspaceRoot = workspaceRoot;
+    this.#directory = directory;
+    this.#rootPackageJson = rootPackageJson;
+    this.#ig = ignore().add(gitignorePatterns);
+    this.#workspaceRoot = workspaceRoot;
   }
   async getMonorepoDependencies(projectName, { pkgs = [], libs = [] } = {}) {
-    const npmSet = new Set(Object.keys({ ...this.rootPackageJson.dependencies, ...this.rootPackageJson.devDependencies }));
+    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((path2) => path2.replace("@libs/", "")).filter((libName) => libName !== projectName);
+    const libDeps = [...libPathDepSet].map((path) => path.replace("@libs/", "")).filter((libName) => libName !== projectName);
     return {
       pkgDeps,
       libDeps,
@@ -52,11 +54,11 @@ class TypeScriptDependencyScanner {
   async getPackageBuildDependencies(projectName) {
     const runtimeDeps = new Set;
     const devDeps = new Set;
-    const sourceFiles = await this.#findTypeScriptFiles(this.directory, {
+    const sourceFiles = await this.#findTypeScriptFiles(this.#directory, {
       excludeBuildFiles: true,
       excludeTestFiles: true
     });
-    const cssFiles = await this.#findCssFiles(this.directory);
+    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);
@@ -67,7 +69,7 @@ class TypeScriptDependencyScanner {
       const fileContent = await FileSys.readText(filePath);
       this.#addNormalizedImports(runtimeDeps, this.#extractCssPluginImports(fileContent), projectName);
     }
-    const buildFilePath = path.join(this.directory, "build.ts");
+    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);
@@ -75,7 +77,7 @@ class TypeScriptDependencyScanner {
     }
     for (const dep of runtimeDeps)
       devDeps.delete(dep);
-    const rootDeps = { ...this.rootPackageJson.dependencies, ...this.rootPackageJson.devDependencies };
+    const rootDeps = { ...this.#rootPackageJson.dependencies, ...this.#rootPackageJson.devDependencies };
     const missingDeps = [];
     for (const dep of [...runtimeDeps, ...devDeps]) {
       if (rootDeps[dep] || await this.#hasWorkspacePackage(dep))
@@ -89,7 +91,7 @@ class TypeScriptDependencyScanner {
     };
   }
   async#hasWorkspacePackage(dep) {
-    const packageJsonPath = path.join(this.workspaceRoot, "pkgs", dep, "package.json");
+    const packageJsonPath = path.join(this.#workspaceRoot, "pkgs", dep, "package.json");
     if (!await Bun.file(packageJsonPath).exists())
       return false;
     try {
@@ -132,9 +134,9 @@ class TypeScriptDependencyScanner {
     this.#fileRuntimeDependencies.clear();
     this.#fileTypeDependencies.clear();
     this.#visitedFiles.clear();
-    const files = await this.#findTypeScriptFiles(this.directory);
+    const files = await this.#findTypeScriptFiles(this.#directory);
     for (const file of files)
-      await this.#analyzeFile(file, this.directory);
+      await this.#analyzeFile(file, this.#directory);
     return this.#fileDependencies;
   }
   async#findTypeScriptFiles(directory, {
@@ -142,18 +144,17 @@ class TypeScriptDependencyScanner {
     excludeTestFiles = false
   } = {}) {
     const files = [];
-    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}/`)))
+      if (isSkippedPath(filePath))
         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))
+      const relativePath = path.relative(this.#workspaceRoot, fullPath);
+      if (this.#ig.ignores(relativePath))
         continue;
       files.push(fullPath);
     }
@@ -161,14 +162,13 @@ class TypeScriptDependencyScanner {
   }
   async#findCssFiles(directory) {
     const files = [];
-    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}/`)))
+      if (isSkippedPath(filePath))
         continue;
       const fullPath = path.join(directory, filePath);
-      const relativePath = path.relative(this.workspaceRoot, fullPath);
-      if (this.ig.ignores(relativePath))
+      const relativePath = path.relative(this.#workspaceRoot, fullPath);
+      if (this.#ig.ignores(relativePath))
         continue;
       files.push(fullPath);
     }
@@ -289,7 +289,7 @@ class TypeScriptDependencyScanner {
       exec.workspace.getPackageJson(),
       exec.workspace.getGitignorePatterns()
     ]);
-    return new TypeScriptDependencyScanner(exec.cwdPath, {
+    return new TypeScriptDependencyScanner2(exec.cwdPath, {
       workspaceRoot: exec.workspace.cwdPath,
       tsconfig,
       rootPackageJson,
@@ -298,4 +298,4 @@ class TypeScriptDependencyScanner {
   }
 }
 
-export { TypeScriptDependencyScanner };
+export { TypeScriptDependencyScanner2 };