@swissjs/swite 0.3.0

package/src/internal/generate-import-map.ts

@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Generate pre-resolved import maps at build time
+ * Licensed under the MIT License.
+ */
+
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { ModuleResolver } from "../resolution/resolver.js";
+import chalk from "chalk";
+import { getPackageRegistry } from "../kernel/package-registry.js";
+import { findSwissLibMonorepo } from "../kernel/package-finder.js";
+
+export interface ImportMap {
+  version: string;
+  generated: number;
+  imports: {
+    [specifier: string]: string; // "@package/name" -> "/path/to/resolved/file"
+  };
+}
+
+/**
+ * Scan workspace and generate import map
+ * This pre-resolves all known packages to eliminate runtime scanning
+ */
+export async function generateImportMap(
+  root: string,
+  workspaceRoot: string | null,
+): Promise<ImportMap> {
+  const resolver = new ModuleResolver(root);
+  const importMap: ImportMap = {
+    version: "1.0",
+    generated: Date.now(),
+    imports: {},
+  };
+
+  console.log(chalk.blue("[ImportMap] Using dynamic package registry..."));
+
+  // Use dynamic package registry instead of manual scanning
+  const registry = getPackageRegistry();
+  const scanRoot = workspaceRoot || root;
+  
+  if (!scanRoot) {
+    console.warn(chalk.yellow("[ImportMap] No workspace root or app root provided, cannot scan packages"));
+    return importMap;
+  }
+  
+  // Add swiss-lib monorepo if it exists
+  const additionalRoots: string[] = [];
+  const swissLib = await findSwissLibMonorepo(root);
+  if (swissLib) {
+    try {
+      const swissPackageJson = path.join(swissLib, "package.json");
+      await fs.access(swissPackageJson);
+      additionalRoots.push(swissLib);
+      console.log(chalk.blue("[ImportMap] Including swiss-lib monorepo..."));
+    } catch {
+      // swiss-lib monorepo not accessible, skip
+    }
+  }
+
+  // Scan workspace using registry
+  try {
+    await registry.scanWorkspace(scanRoot, additionalRoots);
+  } catch (error: any) {
+    console.error(chalk.red(`[ImportMap] Error scanning workspace: ${error.message}`));
+    return importMap;
+  }
+  
+  // Get all discovered packages
+  const packages = registry.getAllPackages().map(pkg => ({
+    name: pkg.name,
+    path: pkg.path,
+  }));
+
+  console.log(
+    chalk.blue(`[ImportMap] Resolving ${packages.length} packages...`),
+  );
+
+  // Resolve each package
+  let resolved = 0;
+  for (const pkg of packages) {
+    try {
+      // Resolve main export
+      const resolvedPath = await resolver.resolve(pkg.name, "");
+      if (resolvedPath && !resolvedPath.startsWith("http")) {
+        importMap.imports[pkg.name] = resolvedPath;
+        resolved++;
+      }
+
+      // Also resolve common subpaths (components, tokens, etc.)
+      const commonSubpaths = [
+        "/components",
+        "/tokens",
+        "/context",
+        "/shell",
+        "/jsx-runtime",
+        "/jsx-dev-runtime",
+      ];
+
+      for (const subpath of commonSubpaths) {
+        try {
+          const subpathSpecifier = `${pkg.name}${subpath}`;
+          const subpathResolved = await resolver.resolve(subpathSpecifier, "");
+          if (subpathResolved && !subpathResolved.startsWith("http")) {
+            importMap.imports[subpathSpecifier] = subpathResolved;
+            resolved++;
+          }
+        } catch {
+          // Subpath doesn't exist, skip
+        }
+      }
+    } catch (error) {
+      console.warn(
+        chalk.yellow(`[ImportMap] Failed to resolve ${pkg.name}:`, error),
+      );
+    }
+  }
+
+  console.log(
+    chalk.green(
+      `[ImportMap] ✅ Generated import map with ${resolved} entries`,
+    ),
+  );
+
+  return importMap;
+}
+
+/**
+ * Save import map to file
+ */
+export async function saveImportMap(
+  importMap: ImportMap,
+  outputPath: string,
+): Promise<void> {
+  await fs.mkdir(path.dirname(outputPath), { recursive: true });
+  await fs.writeFile(outputPath, JSON.stringify(importMap, null, 2), "utf-8");
+  console.log(chalk.green(`[ImportMap] ✅ Saved to ${outputPath}`));
+}
+
+/**
+ * Load import map from file
+ */
+export async function loadImportMap(
+  filePath: string,
+): Promise<ImportMap | null> {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return JSON.parse(content) as ImportMap;
+  } catch {
+    return null;
+  }
+}

package/src/kernel/package-finder.ts

@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Licensed under the MIT License.
+ */
+
+import { promises as fs } from "node:fs";
+import path from "node:path";
+
+/**
+ * Dynamically find package directories by searching up the file tree
+ * No hardcoded paths - works from any directory structure
+ */
+
+export interface PackageLocation {
+  path: string;
+  type: 'swiss-lib' | 'workspace' | 'node_modules';
+}
+
+/**
+ * Find a co-located framework monorepo by scanning sibling directories at each
+ * ancestor level for any workspace root (pnpm-workspace.yaml) that also has a
+ * packages/ directory. Works for any framework directory name.
+ */
+export async function findSwissLibMonorepo(startPath: string): Promise<string | null> {
+  let current = path.resolve(startPath);
+
+  for (let i = 0; i < 20; i++) {
+    const parent = path.dirname(current);
+    if (parent === current) break;
+
+    // Scan siblings of `current` at this parent level
+    try {
+      const entries = await fs.readdir(parent, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name === "node_modules") continue;
+        if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+        const sibling = path.join(parent, entry.name);
+        if (path.resolve(sibling) === path.resolve(current)) continue; // skip self
+
+        if (
+          await fileExists(path.join(sibling, "pnpm-workspace.yaml")) &&
+          await fileExists(path.join(sibling, "packages"))
+        ) {
+          return sibling;
+        }
+      }
+    } catch {
+      // Skip on permission errors
+    }
+
+    current = parent;
+  }
+
+  return null;
+}
+
+/**
+ * Find a specific package by name, searching in:
+ * 1. node_modules (local and workspace)
+ * 2. swiss-lib/packages (if found)
+ * 3. workspace packages (lib/, packages/, modules/)
+ */
+export async function findPackage(
+  packageName: string,
+  startPath: string,
+  workspaceRoot?: string | null
+): Promise<PackageLocation | null> {
+  // 1. Check local node_modules
+  const localNodeModules = path.join(startPath, "node_modules", packageName);
+  if (await fileExists(path.join(localNodeModules, "package.json"))) {
+    return { path: localNodeModules, type: 'node_modules' };
+  }
+  
+  // 2. Check workspace root node_modules
+  if (workspaceRoot) {
+    const workspaceNodeModules = path.join(workspaceRoot, "node_modules", packageName);
+    if (await fileExists(path.join(workspaceNodeModules, "package.json"))) {
+      return { path: workspaceNodeModules, type: 'node_modules' };
+    }
+  }
+  
+  // 3. Check co-located framework monorepo packages/ for any scoped package
+  if (packageName.startsWith("@")) {
+    const monorepo = await findSwissLibMonorepo(startPath);
+    if (monorepo) {
+      const shortName = packageName.split("/")[1];
+      const monorepoPackage = path.join(monorepo, "packages", shortName);
+      if (await fileExists(path.join(monorepoPackage, "package.json"))) {
+        return { path: monorepoPackage, type: 'swiss-lib' };
+      }
+    }
+  }
+
+  // 4. Check workspace packages (lib/, packages/, modules/)
+  if (workspaceRoot) {
+    const packageDirs = ["lib", "packages", "modules", "libraries", "apps"];
+    for (const dir of packageDirs) {
+      const searchDir = path.join(workspaceRoot, dir);
+      if (!(await fileExists(searchDir))) continue;
+      
+      // Try scoped package name
+      if (packageName.startsWith("@")) {
+        const unscoped = packageName.split("/")[1];
+        const packagePath = path.join(searchDir, unscoped);
+        if (await fileExists(path.join(packagePath, "package.json"))) {
+          return { path: packagePath, type: 'workspace' };
+        }
+      }
+      
+      // Try full package name
+      const packagePath = path.join(searchDir, packageName);
+      if (await fileExists(path.join(packagePath, "package.json"))) {
+        return { path: packagePath, type: 'workspace' };
+      }
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Find all possible workspace roots by searching up the tree
+ */
+export async function findWorkspaceRoots(startPath: string): Promise<string[]> {
+  const roots: string[] = [];
+  let current = startPath;
+  
+  for (let i = 0; i < 20; i++) {
+    const workspaceFile = path.join(current, "pnpm-workspace.yaml");
+    const packageJson = path.join(current, "package.json");
+    
+    try {
+      if (await fileExists(workspaceFile)) {
+        roots.push(current);
+      } else if (await fileExists(packageJson)) {
+        const pkg = JSON.parse(await fs.readFile(packageJson, "utf-8"));
+        if (pkg?.workspaces) {
+          roots.push(current);
+        }
+      }
+    } catch {
+      // Continue
+    }
+    
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  
+  return roots;
+}
+
+/**
+ * Check if a file exists
+ */
+async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/kernel/package-registry.ts

@@ -0,0 +1,198 @@
+/*
+ * Package Registry - Dynamic package discovery
+ * Scans workspace to find all packages and caches their locations
+ * No hardcoded paths - discovers packages by scanning package.json files
+ */
+
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import chalk from "chalk";
+
+export interface PackageInfo {
+  name: string;
+  path: string; // Full file system path to package directory
+  packageJson: any;
+}
+
+export class PackageRegistry {
+  private packages = new Map<string, PackageInfo>();
+  private scanned = false;
+  private scanRoots: string[] = [];
+
+  /**
+   * Scan workspace for all packages
+   */
+  async scanWorkspace(
+    workspaceRoot: string,
+    additionalRoots: string[] = []
+  ): Promise<void> {
+    if (this.scanned) {
+      return; // Already scanned
+    }
+
+    // Validate workspace root exists
+    if (!workspaceRoot) {
+      console.warn(chalk.yellow("[PackageRegistry] No workspace root provided, skipping scan"));
+      return;
+    }
+
+    try {
+      const rootStat = await fs.stat(workspaceRoot);
+      if (!rootStat.isDirectory()) {
+        console.warn(chalk.yellow(`[PackageRegistry] Workspace root is not a directory: ${workspaceRoot}`));
+        return;
+      }
+    } catch (error: any) {
+      console.warn(chalk.yellow(`[PackageRegistry] Cannot access workspace root ${workspaceRoot}:`, error.message));
+      return;
+    }
+
+    this.scanRoots = [workspaceRoot, ...additionalRoots.filter(root => root && root !== workspaceRoot)];
+    console.log(chalk.blue(`[PackageRegistry] Scanning workspace for packages...`));
+    console.log(chalk.gray(`[PackageRegistry] Roots: ${this.scanRoots.join(", ")}`));
+
+    for (const root of this.scanRoots) {
+      if (root) {
+        await this.scanDirectory(root);
+      }
+    }
+
+    this.scanned = true;
+    console.log(
+      chalk.green(
+        `[PackageRegistry] ✅ Found ${this.packages.size} packages`
+      )
+    );
+  }
+
+  /**
+   * Recursively scan directory for package.json files
+   */
+  private async scanDirectory(dir: string, depth: number = 0): Promise<void> {
+    if (depth > 15) return; // Prevent infinite recursion
+
+    // Validate directory exists and is accessible
+    try {
+      const dirStat = await fs.stat(dir);
+      if (!dirStat.isDirectory()) {
+        return;
+      }
+    } catch (error: any) {
+      // Directory doesn't exist or permission denied, skip silently
+      if (error.code === "ENOENT" || error.code === "EACCES") {
+        return;
+      }
+      console.warn(chalk.yellow(`[PackageRegistry] Cannot access ${dir}:`, error.message));
+      return;
+    }
+
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          // Skip common directories that shouldn't be scanned
+          if (
+            entry.name === "node_modules" ||
+            entry.name === "dist" ||
+            entry.name === ".git" ||
+            entry.name === ".swite" ||
+            entry.name.startsWith(".")
+          ) {
+            continue;
+          }
+
+          const packageJsonPath = path.join(dir, entry.name, "package.json");
+          
+          try {
+            const packageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
+            const packageJson = JSON.parse(packageJsonContent);
+            
+            if (packageJson.name) {
+              const packagePath = path.join(dir, entry.name);
+              const packageInfo: PackageInfo = {
+                name: packageJson.name,
+                path: packagePath,
+                packageJson,
+              };
+
+              // Store package - if duplicate name, prefer the one found first (or closest to workspace root)
+              if (!this.packages.has(packageJson.name)) {
+                this.packages.set(packageJson.name, packageInfo);
+                console.log(
+                  chalk.gray(
+                    `[PackageRegistry] Found: ${packageJson.name} at ${packagePath}`
+                  )
+                );
+              } else {
+                // Log duplicate but don't overwrite (first found wins)
+                console.log(
+                  chalk.yellow(
+                    `[PackageRegistry] Duplicate package ${packageJson.name} found at ${packagePath}, keeping first`
+                  )
+                );
+              }
+            }
+          } catch (error: any) {
+            // Not a package.json or invalid JSON, continue scanning
+            // Silently ignore - this is expected for non-package directories
+          }
+
+          // Recurse into subdirectories (but skip if we found a package.json here)
+          // This allows nested package layouts (e.g. packages/foo/modules/bar)
+          await this.scanDirectory(path.join(dir, entry.name), depth + 1);
+        }
+      }
+    } catch (error: any) {
+      // Directory read error, log but don't fail
+      if (error.code !== "ENOENT" && error.code !== "EACCES") {
+        console.warn(chalk.yellow(`[PackageRegistry] Error reading directory ${dir}:`, error.message));
+      }
+    }
+  }
+
+  /**
+   * Find package by name
+   */
+  findPackage(packageName: string): PackageInfo | null {
+    return this.packages.get(packageName) || null;
+  }
+
+  /**
+   * Get all packages
+   */
+  getAllPackages(): PackageInfo[] {
+    return Array.from(this.packages.values());
+  }
+
+  /**
+   * Clear cache and rescan
+   */
+  async rescan(): Promise<void> {
+    const roots = [...this.scanRoots];
+    this.packages.clear();
+    this.scanned = false;
+    this.scanRoots = [];
+    
+    if (roots.length > 0) {
+      await this.scanWorkspace(roots[0], roots.slice(1));
+    }
+  }
+
+  /**
+   * Get package count
+   */
+  getPackageCount(): number {
+    return this.packages.size;
+  }
+}
+
+// Singleton instance
+let registryInstance: PackageRegistry | null = null;
+
+export function getPackageRegistry(): PackageRegistry {
+  if (!registryInstance) {
+    registryInstance = new PackageRegistry();
+  }
+  return registryInstance;
+}

package/src/kernel/workspace.ts

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Licensed under the MIT License.
+ */
+
+import { promises as fs } from "node:fs";
+import path from "node:path";
+
+/**
+ * Find the workspace root by looking for pnpm-workspace.yaml or package.json with workspaces
+ * Updated: Now also checks for lib/ directory to ensure we find the correct SWS root
+ */
+export async function findWorkspaceRoot(root: string): Promise<string | null> {
+  let current = root;
+  for (let i = 0; i < 10; i++) { // Increased from 5 to 10 to go higher up
+    const workspaceFile = path.join(current, "pnpm-workspace.yaml");
+    const packageJson = path.join(current, "package.json");
+    const libDir = path.join(current, "lib");
+    
+    try {
+      await fs.access(workspaceFile);
+      // Accept root if it has lib/ (SWS with lib/) or packages/ (SWS with packages/ at root)
+      const packagesDir = path.join(current, "packages");
+      try {
+        await fs.access(libDir);
+        console.log(`[workspace] Found workspace root with lib/: ${current}`);
+        return current;
+      } catch {
+        try {
+          await fs.access(packagesDir);
+          console.log(`[workspace] Found workspace root with packages/: ${current}`);
+          return current;
+        } catch {
+          // Workspace file exists but no lib/ or packages/, continue searching up
+          console.log(`[workspace] Found workspace file at ${current} but no lib/ or packages/, continuing search...`);
+        }
+      }
+    } catch {
+      try {
+        const pkgJson = JSON.parse(await fs.readFile(packageJson, "utf-8"));
+        if (pkgJson?.workspaces) {
+          // Also check for lib/ when package.json has workspaces
+          try {
+            await fs.access(libDir);
+            console.log(`[workspace] Found workspace root with lib/ (via package.json): ${current}`);
+            return current;
+          } catch {
+            // Has workspaces but no lib/, continue searching
+          }
+        }
+      } catch {
+        // Continue searching
+      }
+    }
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  console.warn(`[workspace] No workspace root found starting from: ${root}`);
+  return null;
+}