@swissjs/swite 0.3.0

package/dist/utils/package-registry.js

@@ -0,0 +1,159 @@
+/*
+ * 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 class PackageRegistry {
+    constructor() {
+        this.packages = new Map();
+        this.scanned = false;
+        this.scanRoots = [];
+    }
+    /**
+     * Scan workspace for all packages
+     */
+    async scanWorkspace(workspaceRoot, additionalRoots = []) {
+        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) {
+            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
+     */
+    async scanDirectory(dir, depth = 0) {
+        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) {
+            // 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 = {
+                                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) {
+                        // 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) {
+            // 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) {
+        return this.packages.get(packageName) || null;
+    }
+    /**
+     * Get all packages
+     */
+    getAllPackages() {
+        return Array.from(this.packages.values());
+    }
+    /**
+     * Clear cache and rescan
+     */
+    async rescan() {
+        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() {
+        return this.packages.size;
+    }
+}
+// Singleton instance
+let registryInstance = null;
+export function getPackageRegistry() {
+    if (!registryInstance) {
+        registryInstance = new PackageRegistry();
+    }
+    return registryInstance;
+}

package/dist/utils/workspace.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 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 declare function findWorkspaceRoot(root: string): Promise<string | null>;
+//# sourceMappingURL=workspace.d.ts.map

package/dist/utils/workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../src/utils/workspace.ts"],"names":[],"mappings":"AASA;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAgD5E"}

package/dist/utils/workspace.js

@@ -0,0 +1,65 @@
+/*
+ * 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) {
+    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;
+}

package/docs/IMPORT_REWRITING.md

@@ -0,0 +1,164 @@
+# Import Rewriting in SWITE
+
+## Overview
+
+SWITE automatically rewrites bare module specifiers (e.g., `@swissjs/core`) to valid URLs that the browser can resolve. This document explains how it works and common issues.
+
+## How It Works
+
+### Static Imports
+
+Static imports like `import { X } from '@swissjs/core'` are automatically rewritten to use the resolved path:
+
+```javascript
+// Before
+import { SwissApp } from '@swissjs/core';
+
+// After (rewritten)
+import { SwissApp } from '/swiss-packages/core/src/index.ts';
+```
+
+### Dynamic Imports
+
+Dynamic imports with **string literals** are rewritten:
+
+```javascript
+// ✅ This WILL be rewritten
+const module = await import('@swissjs/router');
+
+// ❌ This will NOT be rewritten (variable reference)
+const module = await import(def.componentUrl);
+```
+
+## Critical Rule: Variable References Are NOT Rewritten
+
+**IMPORTANT**: SWITE only rewrites **string literal** module specifiers. Variable references in dynamic imports are left unchanged.
+
+### Why?
+
+Variable references like `import(def.componentUrl)` are runtime values that cannot be statically analyzed. Rewriting them would break the code:
+
+```javascript
+// ❌ WRONG - This would break
+const module = await import(https://esm.sh/def.componentUrl); // Syntax error!
+
+// ✅ CORRECT - Variable references are left as-is
+const module = await import(def.componentUrl);
+```
+
+### How SWITE Detects This
+
+1. **es-module-lexer path**: Only processes imports with quoted string literals
+2. **Regex fallback path**: Only matches patterns like `import('"specifier"')` with quotes
+
+## Common Issues
+
+### SyntaxError: Unexpected token ':'
+
+**Symptom**: Browser error like `ShellRouter.js:41 Uncaught SyntaxError: Unexpected token ':'`
+
+**Cause**: The import rewriter incorrectly rewrote a variable reference in a dynamic import.
+
+**Solution**: Use an intermediate variable to ensure the import rewriter skips it:
+
+```javascript
+// ✅ REQUIRED - Use intermediate variable
+const url = def.componentUrl;
+const module = await import(url);
+
+// ❌ Wrong - Property access may be incorrectly processed
+const module = await import(def.componentUrl);
+
+// ❌ Wrong - Template literals are still processed
+const module = await import(`${def.componentUrl}`);
+```
+
+### Module Not Found After Rewriting
+
+**Symptom**: Module resolves but file doesn't exist
+
+**Cause**: The resolver returned a path that doesn't exist (e.g., pointing to `dist/` when only `src/` exists)
+
+**Solution**: SWITE automatically prefers `src/` over `dist/` in development. If issues persist, check:
+1. The package's `package.json` exports field
+2. The file actually exists at the resolved path
+3. Server logs for resolution details
+
+## Debugging
+
+Enable verbose logging to see what's being rewritten:
+
+```bash
+# Check server logs for:
+[SWITE] import-rewriter: Resolved <specifier> -> <resolved>
+```
+
+If you see a variable being resolved (e.g., `def.componentUrl`), that's a bug - report it.
+
+## Implementation Details
+
+### es-module-lexer Path (Primary)
+
+1. Parses the code to find all imports
+2. Extracts specifiers (with quotes)
+3. Only processes specifiers that have quotes (string literals)
+4. Skips variable references automatically
+
+### Regex Fallback Path
+
+Used when es-module-lexer fails to parse (e.g., complex template literals):
+
+1. Matches only quoted string literals: `/import\s*\(\s*['"]([^'"]+)['"]\s*\)/g`
+2. Validates specifier looks like a module path
+3. Skips property access patterns (e.g., `def.componentUrl`)
+
+## Best Practices
+
+1. **Use string literals for static module paths**:
+   ```javascript
+   const module = await import('@swissjs/router');
+   ```
+
+2. **Use intermediate variables for runtime-determined paths**:
+   ```javascript
+   // ✅ REQUIRED PATTERN - Use intermediate variable
+   const url = def.componentUrl;
+   const module = await import(url);
+   
+   // ❌ WRONG - Property access may be incorrectly processed
+   const module = await import(def.componentUrl);
+   ```
+
+3. **Why intermediate variables?**
+   - Import rewriter skips simple identifiers (like `url`, `x`, etc.)
+   - Property access patterns (like `def.componentUrl`) may be incorrectly processed
+   - This ensures the variable is treated as a variable, not a module specifier
+
+## Required Pattern for Dynamic Imports with Variables
+
+**ALWAYS** use this pattern when importing from a variable:
+
+```typescript
+// Extract to simple identifier first
+const url = def.componentUrl;
+const module = await import(url);
+```
+
+**Why this works:**
+- Import rewriter validates specifiers and skips simple identifiers
+- Simple identifiers (single word, no dots, no @) are treated as variables
+- Property access patterns may pass validation and be incorrectly processed
+- Using an intermediate variable ensures the import rewriter skips it
+
+**What NOT to do:**
+```typescript
+// ❌ Don't use property access directly
+const module = await import(def.componentUrl);
+
+// ❌ Don't use template literals
+const module = await import(`${def.componentUrl}`);
+
+// ❌ Don't use complex expressions
+const module = await import(config.paths.component);
+```
+

package/docs/IMPORT_REWRITING_TROUBLESHOOTING.md

@@ -0,0 +1,139 @@
+# Import Rewriting Troubleshooting Guide
+
+## The Problem
+
+**Browser Error:**
+```
+Failed to resolve module specifier "@swiss-enterprise/ai-agents". 
+Relative references must start with either "/", "./", or "../".
+```
+
+**Root Cause:**
+The browser cannot resolve bare module specifiers (like `@swiss-enterprise/ai-agents`). SWITE must rewrite them to valid paths (like `/EnterpriseRepo/packages/ai-agents/src/index.ui`) before sending code to the browser.
+
+## Why This Keeps Happening
+
+### 1. **es-module-lexer Returns Unquoted Specifiers**
+
+`es-module-lexer` sometimes returns import positions WITHOUT including the surrounding quotes. For example:
+- Code: `import { X } from '@swiss-enterprise/ai-agents'`
+- Lexer returns: `@swiss-enterprise/ai-agents` (no quotes)
+- Our code must detect the quotes in the original code
+
+### 2. **Quote Detection Logic Fails**
+
+If quote detection fails, the import rewriter skips the import, leaving bare imports in the code sent to the browser.
+
+### 3. **Browser Can't Resolve Bare Imports**
+
+Browsers require:
+- Absolute paths: `/path/to/file.js`
+- Relative paths: `./file.js` or `../file.js`
+- NOT bare specifiers: `@package/name`
+
+## The Fix
+
+### Detection Strategy
+
+1. **Check if lexer included quotes:**
+   ```typescript
+   const hasQuotes = (firstChar === '"' || firstChar === "'") && firstChar === lastChar;
+   ```
+
+2. **If no quotes, check surrounding code:**
+   ```typescript
+   const codeBefore = code.slice(start - 1, start);
+   const codeAfter = code.slice(end, end + 1);
+   const hasQuotesInCode = codeBefore === codeAfter && (codeBefore === '"' || codeBefore === "'");
+   ```
+
+3. **If still no quotes, search for quoted version:**
+   ```typescript
+   const quotedPattern = new RegExp(`(['"])${specifier}\\1`);
+   const match = quotedPattern.exec(code);
+   ```
+
+4. **If found, use those positions for replacement**
+
+### Replacement Strategy
+
+- Always preserve the original quote style (`'` or `"`)
+- Replace the ENTIRE quoted string, not just the specifier
+- Ensure the resolved path is also properly quoted
+
+## What Breaks
+
+### ❌ What Breaks:
+1. **Skipping unquoted specifiers** - Leaves bare imports in browser code
+2. **Wrong quote detection** - Replaces wrong parts of code
+3. **Not finding quoted version** - Skips valid imports
+4. **Variable references** - Accidentally rewriting `import(variable)` as module specifiers
+
+### ✅ What Works:
+1. **Proper quote detection** - Finds quotes even when lexer doesn't include them
+2. **Regex fallback** - Searches code for quoted version if direct detection fails
+3. **Variable validation** - Skips property access patterns (`def.componentUrl`)
+4. **Package name validation** - Only processes valid package names (`@scope/name`)
+
+## How to Avoid This
+
+### For Developers:
+
+1. **Always use quoted imports:**
+   ```typescript
+   // ✅ Good
+   import { X } from '@swiss-enterprise/ai-agents';
+   
+   // ❌ Bad (if compiler removes quotes)
+   import { X } from @swiss-enterprise/ai-agents;
+   ```
+
+2. **Check server logs:**
+   ```
+   [SWITE] import-rewriter: ⚠️ SKIPPING unquoted specifier
+   [.ui] ERROR: Bare imports still present after rewriting
+   ```
+
+3. **Verify rewritten code:**
+   ```bash
+   curl http://localhost:3001/src/index.ui | grep "@swiss-enterprise"
+   # Should return nothing (all imports rewritten)
+   ```
+
+### For SWITE Maintainers:
+
+1. **Test with real code:**
+   - Don't just test with simple strings
+   - Test with actual compiled `.ui` files
+   - Test with `es-module-lexer` output
+
+2. **Handle edge cases:**
+   - Unquoted specifiers from lexer
+   - Mixed quote styles
+   - Dynamic imports with variables
+
+3. **Add comprehensive logging:**
+   - Log when quotes are detected
+   - Log when quotes are NOT detected
+   - Log when regex fallback is used
+
+## Current Status
+
+✅ **Fixed:** Quote detection now uses regex fallback to find quoted versions in code
+✅ **Fixed:** Properly adjusts positions when quotes are found
+✅ **Fixed:** Preserves original quote style during replacement
+
+## Testing
+
+```bash
+# Test import rewriter
+cd SWS/SWISS/packages/swite
+node test-import-rewriter.mjs
+
+# Check server logs
+tail -f /tmp/alpine-dev.log | grep "import-rewriter"
+
+# Verify browser code
+curl http://localhost:3001/src/index.ui | grep "@swiss-enterprise"
+```
+