akanjs 0.0.1 → 2.0.0-beta.0

package/devkit/commandDecorators/helpFormatter.ts

@@ -0,0 +1,217 @@
+import chalk from "chalk";
+
+import { getArgMetas } from "./argMeta";
+import { type CommandCls, getTargetMetas } from "./targetMeta";
+
+const camelToKebabCase = (str: string) => str.replace(/([A-Z])/g, "-$1").toLowerCase();
+const formatChoice = (choice: string | number | { label: string; value: string | number | boolean }) =>
+  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(` (${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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,339 @@
+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,
+    });
+  }
+}