akanjs 2.0.7 → 2.1.0-rc.0

package/devkit/commandDecorators/helpFormatter.ts

@@ -1,220 +0,0 @@
-import chalk from "chalk";
-
-import { type EnumChoice, getArgMetas } from "./argMeta";
-import { type CommandCls, getTargetMetas } from "./targetMeta";
-
-const camelToKebabCase = (str: string) => str.replace(/([A-Z])/g, "-$1").toLowerCase();
-const formatChoice = (choice: EnumChoice) => (typeof choice === "object" ? choice.label : choice.toString());
-
-const groupCommands = (commands: CommandCls[]) => {
-  const groups = new Map<string, { name: string; commands: { key: string; args: string[]; desc?: string }[] }>();
-
-  for (const command of commands) {
-    const className = command.name.replace("Command", "");
-    const groupName = className;
-
-    if (!groups.has(groupName)) {
-      groups.set(groupName, { name: groupName, commands: [] });
-    }
-
-    const targetMetas = getTargetMetas(command);
-    for (const targetMeta of targetMetas) {
-      
-      if (targetMeta.targetOption.devOnly) continue;
-
-      const [allArgMetas] = getArgMetas(command, targetMeta.key);
-      const args = allArgMetas
-        .filter((arg) => arg.type !== "Option")
-        .map((arg) => {
-          if (arg.type === "Workspace") return "";
-          if (arg.type === "Module") return "[sys:module]";
-          if (arg.type === "Argument") {
-            return `[${arg.name}]`;
-          }
-          return `[${arg.type.toLowerCase()}]`;
-        })
-        .filter(Boolean);
-
-      const group = groups.get(groupName);
-      if (group) {
-        group.commands.push({
-          key: camelToKebabCase(targetMeta.key),
-          args,
-          desc: targetMeta.targetOption.desc,
-        });
-      }
-    }
-  }
-
-  return groups;
-};
-
-export const formatHelp = (commands: CommandCls[], version: string) => {
-  const groups = groupCommands(commands);
-  const lines: string[] = [];
-
-  lines.push("");
-  lines.push(chalk.bold.cyan("  ╔═══════════════════════════════════════════════════╗"));
-  lines.push(
-    chalk.bold.cyan("  ║") +
-      chalk.bold.white("              Akan.js Framework CLI            ") +
-      chalk.bold.cyan("    ║"),
-  );
-  lines.push(chalk.bold.cyan("  ╚═══════════════════════════════════════════════════╝"));
-  lines.push("");
-  lines.push(chalk.gray(`  Version: ${version}`));
-  lines.push("");
-
-  lines.push(chalk.bold.yellow("  USAGE"));
-  lines.push("");
-  lines.push(chalk.gray("    $ ") + chalk.white("akan") + chalk.gray(" <command> [options]"));
-  lines.push("");
-
-  lines.push(chalk.bold.yellow("  COMMANDS"));
-  lines.push("");
-
-  for (const [groupName, group] of groups) {
-    
-    if (group.commands.length === 0) continue;
-
-    lines.push(chalk.bold.magenta(`    ${groupName}`));
-    lines.push("");
-
-    for (const cmd of group.commands) {
-      const cmdName = chalk.green(cmd.key);
-      const cmdArgs = cmd.args.length > 0 ? chalk.gray(` ${cmd.args.join(" ")}`) : "";
-
-      if (cmd.desc) {
-        const maxLineLength = 70;
-        const cmdPrefix = `      ${cmdName}${cmdArgs}`;
-        const indent = "        ";
-
-        if (cmdPrefix.length + cmd.desc.length + 3 < maxLineLength) {
-          
-          lines.push(`${cmdPrefix}  ${chalk.gray(cmd.desc)}`);
-        } else {
-          
-          lines.push(cmdPrefix);
-          lines.push(`${indent}${chalk.gray(cmd.desc)}`);
-        }
-      } else {
-        lines.push(`      ${cmdName}${cmdArgs}`);
-      }
-    }
-    lines.push("");
-  }
-
-  lines.push(chalk.bold.yellow("  OPTIONS"));
-  lines.push("");
-  lines.push(`      ${chalk.green("-v, --verbose")}      ${chalk.gray("Enable verbose output")}`);
-  lines.push(`      ${chalk.green("-h, --help")}         ${chalk.gray("Display this help message")}`);
-  lines.push(`      ${chalk.green("-V, --version")}      ${chalk.gray("Output version number")}`);
-  lines.push("");
-
-  lines.push(chalk.bold.yellow("  EXAMPLES"));
-  lines.push("");
-  lines.push(chalk.gray("    # Create a new workspace"));
-  lines.push(chalk.white("    $ akan create-workspace myproject"));
-  lines.push("");
-  lines.push(chalk.gray("    # Start development server"));
-  lines.push(chalk.white("    $ akan start myapp"));
-  lines.push("");
-  lines.push(chalk.gray("    # Create a new module"));
-  lines.push(chalk.white("    $ akan create-module userProfile"));
-  lines.push("");
-
-  lines.push(chalk.gray("  Documentation: ") + chalk.cyan("https://akanjs.com/docs"));
-  lines.push(chalk.gray("  Report issues: ") + chalk.cyan("https://github.com/akan-team/akanjs/issues"));
-  lines.push("");
-
-  return lines.join("\n");
-};
-
-export const formatCommandHelp = (command: CommandCls, key: string) => {
-  const [allArgMetas, argMetas] = getArgMetas(command, key);
-  const kebabKey = camelToKebabCase(key);
-  const lines: string[] = [];
-
-  const targetMetas = getTargetMetas(command);
-  const targetMeta = targetMetas.find((t) => t.key === key);
-  const commandDesc = targetMeta?.targetOption.desc;
-
-  lines.push("");
-  lines.push(chalk.bold.cyan(`  Command: ${kebabKey}`));
-  if (commandDesc) {
-    lines.push(chalk.gray(`  ${commandDesc}`));
-  }
-  lines.push("");
-
-  const args = allArgMetas
-    .filter((arg) => arg.type !== "Option")
-    .map((arg) => {
-      if (arg.type === "Workspace") return "";
-      if (arg.type === "Module") return "[sys:module]";
-      if (arg.type === "Argument") {
-        return `[${camelToKebabCase(arg.name)}]`;
-      }
-      return `[${arg.type.toLowerCase()}]`;
-    })
-    .filter(Boolean)
-    .join(" ");
-
-  lines.push(chalk.bold.yellow("  USAGE"));
-  lines.push("");
-  lines.push(chalk.gray("    $ ") + chalk.white(`akan ${kebabKey}`) + (args ? chalk.gray(` ${args}`) : ""));
-  lines.push("");
-
-  const nonOptionArgs = allArgMetas.filter((arg) => arg.type !== "Option");
-  if (nonOptionArgs.length > 0) {
-    lines.push(chalk.bold.yellow("  ARGUMENTS"));
-    lines.push("");
-
-    for (const arg of nonOptionArgs) {
-      if (arg.type === "Workspace") continue;
-
-      let argName: string;
-      let argDesc: string;
-      let example = "";
-
-      if (arg.type === "Argument") {
-        argName = camelToKebabCase(arg.name);
-        argDesc = arg.argsOption.desc ?? "";
-        example = arg.argsOption.example ? chalk.gray(` (e.g., ${String(arg.argsOption.example)})`) : "";
-      } else if (arg.type === "Module") {
-        argName = "sys:module";
-        argDesc = "Module in format: app-name:module-name or lib-name:module-name";
-      } else {
-        argName = arg.type.toLowerCase();
-        argDesc = `${arg.type} name in this workspace`;
-      }
-
-      lines.push(`      ${chalk.green(argName)}      ${chalk.gray(argDesc)}${example}`);
-    }
-
-    lines.push("");
-  }
-
-  const optionArgs = argMetas.filter((a) => a.type === "Option");
-  if (optionArgs.length > 0) {
-    lines.push(chalk.bold.yellow("  OPTIONS"));
-    lines.push("");
-
-    for (const arg of optionArgs) {
-      const opt = arg.argsOption;
-      const flag = opt.flag ? `-${opt.flag}, ` : "";
-      const kebabName = camelToKebabCase(arg.name);
-      const optName = `${flag}--${kebabName}`;
-      const optDesc = opt.desc ?? "";
-      const defaultVal = opt.default !== undefined ? chalk.gray(` [default: ${String(opt.default)}]`) : "";
-      const choices = opt.enum
-        ? chalk.gray(
-            typeof opt.enum === "function" ? " ([dynamic choices])" : ` (${opt.enum.map(formatChoice).join(", ")})`,
-          )
-        : "";
-      lines.push(`      ${chalk.green(optName)}      ${chalk.gray(optDesc)}${defaultVal}${choices}`);
-    }
-    lines.push("");
-  }
-
-  return lines.join("\n");
-};

package/devkit/commandDecorators/index.ts

@@ -1,8 +0,0 @@
-export * from "./argMeta";
-export * from "./command";
-export * from "./commandBuilder";
-export * from "./commandMeta";
-export * from "./dependencyBuilder";
-export * from "./helpFormatter";
-export * from "./targetMeta";
-export * from "./types";

package/devkit/commandDecorators/targetMeta.ts

@@ -1,31 +0,0 @@
-import type { ArgMeta, InternalArgMeta } from "./argMeta";
-import type { DependencyCls } from "./types";
-
-export const COMMAND_META: unique symbol = Symbol("akan.command.meta");
-
-export interface TargetMeta {
-  key: string;
-  targetOption: TargetOption;
-  args: (ArgMeta | InternalArgMeta)[];
-  handler: (this: unknown, ...args: unknown[]) => unknown | Promise<unknown>;
-}
-
-export interface CommandStatics {
-  [COMMAND_META]: Map<string, TargetMeta>;
-}
-
-export type CommandCls<Instance = unknown, Key extends string = string> = DependencyCls<Instance, Key> & CommandStatics;
-
-export const getTargetMetas = (command: CommandCls): TargetMeta[] => {
-  const targetMetaMap = command[COMMAND_META];
-  if (!targetMetaMap) throw new Error(`TargetMeta is not defined for ${command.name}`);
-  return [...targetMetaMap.values()];
-};
-
-export interface TargetOption {
-  type: "public" | "cloud" | "dev";
-  short?: string | true;
-  devOnly?: boolean;
-  desc?: string;
-  runsOnWorkspaceRoot?: boolean;
-}

package/devkit/commandDecorators/types.ts

@@ -1,10 +0,0 @@
-export type Cls<T = unknown> = new (...args: unknown[]) => T;
-
-export type DependencyKind = "command" | "script" | "runner";
-export type DependencyKey<RefName extends string, Kind extends DependencyKind> = `${RefName}${Capitalize<Kind>}`;
-
-export type DependencyCls<T = unknown, Key extends string = string> = (new () => T) & {
-  readonly dependencyKey: Key;
-  readonly dependencyKind: DependencyKind;
-  readonly refName: string;
-};

package/devkit/constants.ts

@@ -1,25 +0,0 @@
-import type { SupportedLlmModel } from "./aiEditor";
-
-export const basePath = `${Bun.env.HOME ?? Bun.env.USERPROFILE}/.akan`;
-export const configPath = `${basePath}/config.json`;
-export const akanCloudHost =
-  process.env.AKAN_PUBLIC_OPERATION_MODE === "local" ? "http://localhost" : "https://cloud.akanjs.com";
-export const akanCloudUrl = `${akanCloudHost}${process.env.AKAN_PUBLIC_OPERATION_MODE === "local" ? ":8282" : ""}/메ㅑ`;
-
-export interface HostConfig {
-  auth?: {
-    token: string;
-    self: { id: string; nickname: string };
-  };
-}
-export const defaultHostConfig: HostConfig = {};
-export interface AkanGlobalConfig {
-  cloudHost: {
-    [key: string]: HostConfig;
-  };
-  llm: {
-    model: SupportedLlmModel;
-    apiKey: string;
-  } | null;
-}
-export const defaultAkanGlobalConfig: AkanGlobalConfig = { cloudHost: {}, llm: null };

package/devkit/createTunnel.ts

@@ -1,36 +0,0 @@
-import type { SshOptions } from "akanjs/base";
-
-import { type AppExecutor, WorkspaceExecutor } from "./executors";
-import { createSshTunnel } from "./sshTunnel";
-
-const getSshTunnelOptions = (app: AppExecutor, environment: string): SshOptions => {
-  const { serveDomain, repoName } = WorkspaceExecutor.getBaseDevEnv();
-  return {
-    host: `${app.name}-${environment}.${serveDomain}`,
-    port: process.env.SSH_TUNNEL_PORT ? parseInt(process.env.SSH_TUNNEL_PORT) : 32767,
-    username: process.env.SSH_TUNNEL_USERNAME ?? "root",
-    password: process.env.SSH_TUNNEL_PASSWORD ?? repoName,
-  };
-};
-
-interface TunnelOption {
-  app: AppExecutor;
-  environment: string;
-  port?: number;
-}
-export const createTunnel = async (
-  service: "redis" | "postgres",
-  { app, environment, port = service === "postgres" ? 5432 : 6379 }: TunnelOption,
-) => {
-  const sshOptions: SshOptions = getSshTunnelOptions(app, environment);
-  await createSshTunnel({
-    localHost: "0.0.0.0",
-    localPort: port,
-    srcHost: "0.0.0.0",
-    srcPort: port,
-    dstHost: `${service}-0.${service}-svc.${app.name}-${environment}.svc.cluster.local`,
-    dstPort: service === "postgres" ? 5432 : 6379,
-    sshOptions,
-  });
-  return `localhost:${port}`;
-};

package/devkit/dependencyScanner.ts

@@ -1,339 +0,0 @@
-import { builtinModules } from "node:module";
-import * as path from "node:path";
-import ignore from "ignore";
-import ts from "typescript";
-import type { App, Lib, Pkg } from "./commandDecorators";
-import { FileSys } from "./fileSys";
-import type { PackageJson, TsConfigJson } from "./types";
-
-const testFileRegex = /\.(?:test|spec)\.[cm]?[tj]sx?$/;
-const builtinModuleSet = new Set([...builtinModules, ...builtinModules.map((mod) => `node:${mod}`)]);
-const stripShebang = (source: string) => source.replace(/^#!.*(?:\r?\n|$)/, "");
-
-export class TypeScriptDependencyScanner {
-  #fileDependencies = new Map<string, string[]>();
-  #fileRuntimeDependencies = new Map<string, string[]>();
-  #fileTypeDependencies = new Map<string, string[]>();
-  #visitedFiles = new Set<string>();
-  readonly #tsTranspiler = new Bun.Transpiler({ loader: "ts" });
-  readonly #tsxTranspiler = new Bun.Transpiler({ loader: "tsx" });
-  private readonly directory: string;
-  private readonly rootPackageJson: PackageJson;
-  private readonly ig: ReturnType<typeof ignore>;
-  private readonly workspaceRoot: string;
-
-  constructor(
-    directory: string,
-    {
-      workspaceRoot,
-      rootPackageJson,
-      gitignorePatterns = [],
-    }: { workspaceRoot: string; tsconfig: TsConfigJson; rootPackageJson: PackageJson; gitignorePatterns?: string[] },
-  ) {
-    this.directory = directory;
-    this.rootPackageJson = rootPackageJson;
-    this.ig = ignore().add(gitignorePatterns);
-    this.workspaceRoot = workspaceRoot;
-  }
-
-  async getMonorepoDependencies(
-    projectName: string,
-    { pkgs = [], libs = [] }: { pkgs?: string[]; libs?: string[] } = {},
-  ): Promise<{ pkgDeps: string[]; libDeps: string[]; npmDeps: string[]; npmDevDeps: string[] }> {
-    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((path) => path.replace("@libs/", ""))
-      .filter((libName) => libName !== projectName);
-    return {
-      pkgDeps,
-      libDeps,
-      npmDeps: [...npmDepSet],
-      npmDevDeps: [...npmDevDepSet].filter((dep) => !npmDepSet.has(dep)),
-    };
-  }
-
-  async getPackageBuildDependencies(
-    projectName: string,
-  ): Promise<{ npmDeps: string[]; npmDevDeps: string[]; missingDeps: string[] }> {
-    const runtimeDeps = new Set<string>();
-    const devDeps = new Set<string>();
-    const sourceFiles = await this.#findTypeScriptFiles(this.directory, {
-      excludeBuildFiles: true,
-      excludeTestFiles: true,
-    });
-    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);
-      this.#addNormalizedImports(runtimeDeps, imports, projectName);
-      this.#addNormalizedImports(devDeps, typeImports, projectName);
-    }
-
-    for (const filePath of cssFiles) {
-      const fileContent = await FileSys.readText(filePath);
-      this.#addNormalizedImports(runtimeDeps, this.#extractCssPluginImports(fileContent), projectName);
-    }
-
-    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);
-      this.#addNormalizedImports(devDeps, [...imports, ...typeImports], projectName);
-    }
-
-    for (const dep of runtimeDeps) devDeps.delete(dep);
-
-    const rootDeps = { ...this.rootPackageJson.dependencies, ...this.rootPackageJson.devDependencies };
-    const missingDeps = [...runtimeDeps, ...devDeps].filter((dep) => !rootDeps[dep]).sort();
-    return {
-      npmDeps: [...runtimeDeps].sort(),
-      npmDevDeps: [...devDeps].sort(),
-      missingDeps,
-    };
-  }
-
-  async getImportSets<DepSets extends Set<string>[]>(depSets: DepSets): Promise<DepSets> {
-    const fileDependencies = await this.getDependencies();
-    return this.#getImportSetsFromDependencies(depSets, fileDependencies);
-  }
-
-  #getImportSetsFromDependencies<DepSets extends Set<string>[]>(
-    depSets: DepSets,
-    fileDependencies: Map<string, string[]>,
-  ): DepSets {
-    const importedDepSets = new Array<Set<string>>(depSets.length);
-    for (let i = 0; i < depSets.length; i++) importedDepSets[i] = new Set<string>();
-    fileDependencies.forEach((imps) => {
-      imps.forEach((imp) => {
-        if (imp.startsWith(".")) return;
-        const moduleName = imp;
-        const moduleNameParts = moduleName.split("/");
-        const subModuleLength = moduleNameParts.length;
-        for (let i = 0; i < subModuleLength; i++) {
-          const importName = moduleNameParts.slice(0, i + 1).join("/");
-          for (let j = 0; j < depSets.length; j++) {
-            if (depSets[j]?.has(importName)) {
-              importedDepSets[j]?.add(importName);
-              return;
-            }
-          }
-        }
-      });
-    });
-    return importedDepSets as DepSets;
-  }
-
-  async getDependencies(): Promise<Map<string, string[]>> {
-    this.#fileDependencies.clear();
-    this.#fileRuntimeDependencies.clear();
-    this.#fileTypeDependencies.clear();
-    this.#visitedFiles.clear();
-
-    const files = await this.#findTypeScriptFiles(this.directory);
-
-    for (const file of files) await this.#analyzeFile(file, this.directory);
-
-    return this.#fileDependencies;
-  }
-
-  async #findTypeScriptFiles(
-    directory: string,
-    {
-      excludeBuildFiles = false,
-      excludeTestFiles = false,
-    }: { excludeBuildFiles?: boolean; excludeTestFiles?: boolean } = {},
-  ): Promise<string[]> {
-    const files: string[] = [];
-    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}/`))) 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)) continue;
-
-      files.push(fullPath);
-    }
-    return files;
-  }
-
-  async #findCssFiles(directory: string): Promise<string[]> {
-    const files: string[] = [];
-    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}/`))) continue;
-
-      const fullPath = path.join(directory, filePath);
-      const relativePath = path.relative(this.workspaceRoot, fullPath);
-      if (this.ig.ignores(relativePath)) continue;
-
-      files.push(fullPath);
-    }
-    return files;
-  }
-
-  async #analyzeFile(filePath: string, baseDir: string): Promise<void> {
-    if (this.#visitedFiles.has(filePath)) return;
-
-    this.#visitedFiles.add(filePath);
-
-    try {
-      const fileContent = await FileSys.readText(filePath);
-      const { imports, typeImports } = this.#extractImports(fileContent, filePath);
-
-      const resolvedImports = await this.#resolveImports(imports, filePath, baseDir);
-      const resolvedTypeImports = await this.#resolveImports(typeImports, filePath, baseDir);
-
-      const relativePath = path.relative(baseDir, filePath);
-      this.#fileDependencies.set(relativePath, [...new Set([...resolvedImports, ...resolvedTypeImports])]);
-      this.#fileRuntimeDependencies.set(relativePath, resolvedImports);
-      this.#fileTypeDependencies.set(relativePath, resolvedTypeImports);
-    } catch {
-    }
-  }
-
-  async #resolveImports(imports: string[], filePath: string, baseDir: string): Promise<string[]> {
-    return await Promise.all(
-      imports.map(async (importPath) => {
-        if (importPath.startsWith(".")) {
-          
-          const resolvedPath = `./${path.join(path.relative(baseDir, filePath), importPath)}`;
-          return await this.#ensureExtension(resolvedPath);
-        }
-        return importPath; 
-      }),
-    );
-  }
-
-  async #ensureExtension(filePath: string): Promise<string> {
-    if (await FileSys.fileExists(`${filePath}.ts`)) return `${filePath}.ts`;
-    else if (await FileSys.fileExists(`${filePath}.tsx`)) return `${filePath}.tsx`;
-    else if (await FileSys.fileExists(filePath)) return filePath;
-    return `${filePath}.ts`;
-  }
-
-  #extractImports(source: string, filePath: string) {
-    const transpiler = filePath.endsWith(".tsx") ? this.#tsxTranspiler : this.#tsTranspiler;
-    const scanSource = stripShebang(source);
-    const imports = new Set(
-      transpiler
-        .scanImports(scanSource)
-        .map((imp) => imp.path)
-        .filter(Boolean),
-    );
-    const typeImports = new Set<string>();
-
-    const sourceFile = ts.createSourceFile(filePath, scanSource, ts.ScriptTarget.Latest, true);
-    for (const statement of sourceFile.statements) {
-      if (!ts.isImportDeclaration(statement)) continue;
-      if (!ts.isStringLiteral(statement.moduleSpecifier)) continue;
-
-      const importPath = statement.moduleSpecifier.text;
-      const namedBindings = statement.importClause?.namedBindings;
-      const isNamedTypeOnlyImport =
-        namedBindings &&
-        ts.isNamedImports(namedBindings) &&
-        namedBindings.elements.length > 0 &&
-        namedBindings.elements.every((element) => element.isTypeOnly);
-
-      if ((statement.importClause?.isTypeOnly || isNamedTypeOnlyImport) && !imports.has(importPath)) {
-        typeImports.add(importPath);
-      }
-    }
-
-    return { imports: [...imports], typeImports: [...typeImports] };
-  }
-
-  #extractCssPluginImports(source: string) {
-    const imports = new Set<string>();
-    const pluginRegex = /@plugin\s+(?:url\()?["']([^"')]+)["']\)?/g;
-    for (const match of source.matchAll(pluginRegex)) {
-      const importPath = match[1];
-      if (importPath) imports.add(importPath);
-    }
-    return [...imports];
-  }
-
-  #addNormalizedImports(deps: Set<string>, imports: string[], projectName: string) {
-    for (const importPath of imports) {
-      const dep = this.#normalizePackageImport(importPath, projectName);
-      if (dep) deps.add(dep);
-    }
-  }
-
-  #normalizePackageImport(importPath: string, projectName: string): string | null {
-    if (
-      importPath.startsWith(".") ||
-      importPath.startsWith("/") ||
-      importPath.startsWith("#") ||
-      importPath.startsWith("bun:") ||
-      builtinModuleSet.has(importPath)
-    )
-      return null;
-
-    const parts = importPath.split("/");
-    const packageName = importPath.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
-    if (!packageName || packageName === projectName || importPath.startsWith(`${projectName}/`)) return null;
-    return packageName;
-  }
-
-  generateDependencyGraph(): string {
-    let graph = "Dependency Graph:\n\n";
-
-    for (const [file, imports] of this.#fileDependencies.entries()) {
-      graph += `${file}:\n`;
-
-      const projectImports = imports.filter((i) => !i.startsWith("react") && !i.startsWith("@"));
-      const externalImports = imports.filter((i) => i.startsWith("react") || i.startsWith("@"));
-
-      if (projectImports.length > 0) {
-        graph += "  Project dependencies:\n";
-        projectImports.forEach((imp) => {
-          graph += `    → ${imp}\n`;
-        });
-      }
-
-      if (externalImports.length > 0) {
-        graph += "  External dependencies:\n";
-        externalImports.forEach((imp) => {
-          graph += `    → ${imp}\n`;
-        });
-      }
-
-      graph += "\n";
-    }
-
-    return graph;
-  }
-
-  static async from(exec: App | Lib | Pkg) {
-    const [tsconfig, rootPackageJson, gitignorePatterns] = await Promise.all([
-      exec.getTsConfig(),
-      exec.workspace.getPackageJson(),
-      exec.workspace.getGitignorePatterns(),
-    ]);
-    return new TypeScriptDependencyScanner(exec.cwdPath, {
-      workspaceRoot: exec.workspace.cwdPath,
-      tsconfig,
-      rootPackageJson,
-      gitignorePatterns,
-    });
-  }
-}