@fairfox/polly 0.2.0 → 0.3.0

package/dist/vendor/visualize/src/cli.js

@@ -13,13 +13,448 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// vendor/analysis/src/extract/project-detector.ts
+var exports_project_detector = {};
+__export(exports_project_detector, {
+  detectProjectConfig: () => detectProjectConfig,
+  ProjectDetector: () => ProjectDetector
+});
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+
+class ProjectDetector {
+  projectRoot;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  detect() {
+    const manifestPath = path3.join(this.projectRoot, "manifest.json");
+    if (fs3.existsSync(manifestPath)) {
+      return this.detectChromeExtension(manifestPath);
+    }
+    const pwaManifestPath = path3.join(this.projectRoot, "public", "manifest.json");
+    if (fs3.existsSync(pwaManifestPath)) {
+      return this.detectPWA(pwaManifestPath);
+    }
+    const packageJsonPath = path3.join(this.projectRoot, "package.json");
+    if (fs3.existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
+      if (packageJson.dependencies?.electron || packageJson.devDependencies?.electron) {
+        return this.detectElectron(packageJson);
+      }
+      const deps = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies
+      };
+      if (deps?.ws || deps?.["socket.io"] || deps?.elysia || deps?.express || deps?.fastify || deps?.hono || deps?.koa) {
+        return this.detectWebSocketApp(packageJson);
+      }
+      const serverResult = this.detectWebSocketApp(packageJson);
+      if (Object.keys(serverResult.entryPoints).length > 0) {
+        return serverResult;
+      }
+    } else {
+      const serverResult = this.detectWebSocketApp({});
+      if (Object.keys(serverResult.entryPoints).length > 0) {
+        return serverResult;
+      }
+    }
+    return this.detectGenericProject();
+  }
+  detectChromeExtension(manifestPath) {
+    const manifest = JSON.parse(fs3.readFileSync(manifestPath, "utf-8"));
+    const entryPoints = {};
+    const background = manifest.background;
+    if (background) {
+      const file = background.service_worker || background.scripts?.[0] || background.page;
+      if (file) {
+        entryPoints.background = this.findSourceFile(file);
+      }
+    }
+    const contentScripts = manifest.content_scripts;
+    if (contentScripts && contentScripts.length > 0) {
+      const firstScript = contentScripts[0].js?.[0];
+      if (firstScript) {
+        entryPoints.content = this.findSourceFile(firstScript);
+      }
+    }
+    const popup = manifest.action?.default_popup || manifest.browser_action?.default_popup;
+    if (popup) {
+      const jsFile = this.findAssociatedJS(path3.join(this.projectRoot, popup));
+      if (jsFile)
+        entryPoints.popup = jsFile;
+    }
+    const options = manifest.options_ui?.page || manifest.options_page;
+    if (options) {
+      const jsFile = this.findAssociatedJS(path3.join(this.projectRoot, options));
+      if (jsFile)
+        entryPoints.options = jsFile;
+    }
+    return {
+      type: "chrome-extension",
+      entryPoints,
+      metadata: {
+        name: manifest.name,
+        version: manifest.version,
+        description: manifest.description
+      }
+    };
+  }
+  detectPWA(manifestPath) {
+    const manifest = JSON.parse(fs3.readFileSync(manifestPath, "utf-8"));
+    const entryPoints = {};
+    const swCandidates = [
+      "src/service-worker.ts",
+      "src/sw.ts",
+      "public/service-worker.js",
+      "public/sw.js"
+    ];
+    for (const candidate of swCandidates) {
+      const fullPath = path3.join(this.projectRoot, candidate);
+      if (fs3.existsSync(fullPath)) {
+        entryPoints.worker = fullPath;
+        break;
+      }
+    }
+    const clientCandidates = [
+      "src/main.ts",
+      "src/index.ts",
+      "src/app.ts",
+      "src/main.tsx",
+      "src/index.tsx"
+    ];
+    for (const candidate of clientCandidates) {
+      const fullPath = path3.join(this.projectRoot, candidate);
+      if (fs3.existsSync(fullPath)) {
+        entryPoints.client = fullPath;
+        break;
+      }
+    }
+    return {
+      type: "pwa",
+      entryPoints,
+      contextMapping: {
+        worker: "Service Worker",
+        client: "Client App"
+      },
+      metadata: {
+        name: manifest.name || manifest.short_name,
+        version: "1.0.0",
+        description: manifest.description
+      }
+    };
+  }
+  detectElectron(packageJson) {
+    const entryPoints = {};
+    const mainCandidates = [
+      packageJson.main,
+      "src/main/index.ts",
+      "src/electron/main.ts",
+      "electron/main.ts",
+      "main.ts"
+    ].filter(Boolean);
+    for (const candidate of mainCandidates) {
+      const fullPath = path3.join(this.projectRoot, candidate);
+      if (fs3.existsSync(fullPath) || fs3.existsSync(fullPath.replace(/\.js$/, ".ts"))) {
+        entryPoints.main = fs3.existsSync(fullPath) ? fullPath : fullPath.replace(/\.js$/, ".ts");
+        break;
+      }
+    }
+    const rendererCandidates = [
+      "src/renderer/index.tsx",
+      "src/renderer/index.ts",
+      "src/index.tsx",
+      "src/index.ts"
+    ];
+    for (const candidate of rendererCandidates) {
+      const fullPath = path3.join(this.projectRoot, candidate);
+      if (fs3.existsSync(fullPath)) {
+        entryPoints.renderer = fullPath;
+        break;
+      }
+    }
+    return {
+      type: "electron",
+      entryPoints,
+      contextMapping: {
+        main: "Main Process",
+        renderer: "Renderer Process"
+      },
+      metadata: {
+        name: packageJson.name,
+        version: packageJson.version,
+        description: packageJson.description
+      }
+    };
+  }
+  detectWebSocketApp(packageJson) {
+    const entryPoints = {};
+    const contextMapping = {};
+    const serverCandidates = [
+      "src/server.ts",
+      "src/server.js",
+      "src/index.ts",
+      "src/index.js",
+      "src/main.ts",
+      "src/main.js",
+      "src/app.ts",
+      "src/app.js",
+      "server.ts",
+      "server.js",
+      "index.ts",
+      "index.js"
+    ];
+    const scoredServers = this.scoreServerCandidates(serverCandidates);
+    if (scoredServers.length > 0) {
+      const best = scoredServers[0];
+      entryPoints.server = best.path;
+      if (best.hasWebSocket) {
+        contextMapping.server = "WebSocket Server";
+      } else if (best.hasHTTP) {
+        contextMapping.server = "HTTP Server";
+      } else {
+        contextMapping.server = "Server";
+      }
+    }
+    const clientCandidates = [
+      "src/client/index.ts",
+      "src/client/index.js",
+      "src/client.ts",
+      "src/client.js",
+      "client/index.ts",
+      "client/index.js"
+    ];
+    for (const candidate of clientCandidates) {
+      const fullPath = path3.join(this.projectRoot, candidate);
+      if (fs3.existsSync(fullPath)) {
+        entryPoints.client = fullPath;
+        contextMapping.client = "Client";
+        break;
+      }
+    }
+    return {
+      type: "websocket-app",
+      entryPoints,
+      contextMapping: Object.keys(contextMapping).length > 0 ? contextMapping : {
+        server: "Server",
+        client: "Client"
+      },
+      metadata: {
+        name: packageJson.name,
+        version: packageJson.version,
+        description: packageJson.description
+      }
+    };
+  }
+  scoreServerCandidates(candidates) {
+    const scored = [];
+    for (const candidate of candidates) {
+      const fullPath = path3.join(this.projectRoot, candidate);
+      if (!fs3.existsSync(fullPath))
+        continue;
+      try {
+        const content = fs3.readFileSync(fullPath, "utf-8");
+        let score = 0;
+        let hasWebSocket = false;
+        let hasHTTP = false;
+        let framework = null;
+        const patterns = {
+          bunWebSocket: /Bun\.serve\s*\([^)]*websocket\s*:/i,
+          bunHTTP: /Bun\.serve\s*\(/i,
+          wsServer: /new\s+WebSocket\.Server/i,
+          wsImport: /from\s+['"]ws['"]/,
+          socketIO: /io\s*\(|require\s*\(\s*['"]socket\.io['"]\s*\)/i,
+          elysia: /new\s+Elysia\s*\(|\.ws\s*\(/i,
+          elysiaImport: /from\s+['"]elysia['"]/,
+          express: /express\s*\(\)|app\.listen/i,
+          expressWs: /expressWs\s*\(/i,
+          httpServer: /createServer|app\.listen|server\.listen/i,
+          webSocket: /WebSocket|websocket|\.ws\s*\(|wss\s*:/i
+        };
+        if (patterns.bunWebSocket.test(content)) {
+          score += 15;
+          hasWebSocket = true;
+          hasHTTP = true;
+          framework = "Bun";
+        } else if (patterns.bunHTTP.test(content)) {
+          score += 10;
+          hasHTTP = true;
+          framework = "Bun";
+        }
+        if (patterns.wsServer.test(content) || patterns.wsImport.test(content)) {
+          score += 12;
+          hasWebSocket = true;
+          framework = framework || "ws";
+        }
+        if (patterns.socketIO.test(content)) {
+          score += 12;
+          hasWebSocket = true;
+          framework = framework || "socket.io";
+        }
+        if (patterns.elysia.test(content) || patterns.elysiaImport.test(content)) {
+          score += 10;
+          hasHTTP = true;
+          framework = framework || "Elysia";
+        }
+        if (patterns.elysiaImport.test(content) && patterns.webSocket.test(content)) {
+          score += 8;
+          hasWebSocket = true;
+        }
+        if (patterns.express.test(content)) {
+          score += 8;
+          hasHTTP = true;
+          framework = framework || "Express";
+        }
+        if (patterns.expressWs.test(content)) {
+          score += 5;
+          hasWebSocket = true;
+        }
+        if (patterns.httpServer.test(content) && !hasHTTP) {
+          score += 5;
+          hasHTTP = true;
+        }
+        if (patterns.webSocket.test(content) && !hasWebSocket) {
+          score += 3;
+          hasWebSocket = true;
+        }
+        if (/\.listen\s*\(/.test(content)) {
+          score += 5;
+        }
+        if (/export\s+default/.test(content)) {
+          score += 3;
+        }
+        if (candidate.includes("server")) {
+          score += 3;
+        }
+        if (candidate === "src/index.ts" || candidate === "src/index.js") {
+          score += 2;
+        }
+        if (score > 0) {
+          scored.push({ path: fullPath, score, hasWebSocket, hasHTTP, framework });
+        }
+      } catch (error) {
+        continue;
+      }
+    }
+    return scored.sort((a, b) => b.score - a.score);
+  }
+  detectGenericProject() {
+    const entryPoints = {};
+    const tsConfigPath = path3.join(this.projectRoot, "tsconfig.json");
+    if (fs3.existsSync(tsConfigPath)) {
+      try {
+        const tsConfig = JSON.parse(fs3.readFileSync(tsConfigPath, "utf-8"));
+        if (tsConfig.files && Array.isArray(tsConfig.files)) {
+          tsConfig.files.forEach((file, idx) => {
+            const fullPath = path3.join(this.projectRoot, file);
+            if (fs3.existsSync(fullPath)) {
+              entryPoints[`module${idx + 1}`] = fullPath;
+            }
+          });
+        }
+      } catch (error) {
+        console.warn(`Failed to parse tsconfig.json: ${error}`);
+      }
+    }
+    if (Object.keys(entryPoints).length === 0) {
+      const commonEntries = [
+        "src/index.ts",
+        "src/main.ts",
+        "src/app.ts",
+        "index.ts",
+        "main.ts"
+      ];
+      for (const candidate of commonEntries) {
+        const fullPath = path3.join(this.projectRoot, candidate);
+        if (fs3.existsSync(fullPath)) {
+          entryPoints.main = fullPath;
+          break;
+        }
+      }
+    }
+    const packageJsonPath = path3.join(this.projectRoot, "package.json");
+    let metadata = { name: "Unknown Project" };
+    if (fs3.existsSync(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
+        metadata = {
+          name: packageJson.name,
+          version: packageJson.version,
+          description: packageJson.description
+        };
+      } catch (error) {
+        console.warn(`Failed to parse package.json: ${error}`);
+      }
+    }
+    return {
+      type: "generic",
+      entryPoints,
+      metadata
+    };
+  }
+  findSourceFile(manifestPath) {
+    const candidates = [
+      path3.join(this.projectRoot, manifestPath),
+      path3.join(this.projectRoot, manifestPath.replace(/\.js$/, ".ts")),
+      path3.join(this.projectRoot, "src", manifestPath),
+      path3.join(this.projectRoot, "src", manifestPath.replace(/\.js$/, ".ts")),
+      path3.join(this.projectRoot, "src", manifestPath.replace(/\.js$/, ".tsx"))
+    ];
+    for (const candidate of candidates) {
+      if (fs3.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    return path3.join(this.projectRoot, manifestPath);
+  }
+  findAssociatedJS(htmlPath) {
+    if (!fs3.existsSync(htmlPath)) {
+      return null;
+    }
+    const html = fs3.readFileSync(htmlPath, "utf-8");
+    const scriptMatch = html.match(/<script[^>]+src=["']([^"']+)["']/i);
+    if (scriptMatch && scriptMatch[1]) {
+      const scriptPath = scriptMatch[1];
+      const fullPath = path3.resolve(path3.dirname(htmlPath), scriptPath);
+      if (fs3.existsSync(fullPath))
+        return fullPath;
+      if (fs3.existsSync(fullPath.replace(/\.js$/, ".ts"))) {
+        return fullPath.replace(/\.js$/, ".ts");
+      }
+      if (fs3.existsSync(fullPath.replace(/\.js$/, ".tsx"))) {
+        return fullPath.replace(/\.js$/, ".tsx");
+      }
+    }
+    const baseName = path3.basename(htmlPath, ".html");
+    const dir = path3.dirname(htmlPath);
+    const candidates = [
+      path3.join(dir, `${baseName}.ts`),
+      path3.join(dir, `${baseName}.tsx`),
+      path3.join(dir, `${baseName}.js`),
+      path3.join(dir, "index.ts"),
+      path3.join(dir, "index.tsx")
+    ];
+    for (const candidate of candidates) {
+      if (fs3.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    return null;
+  }
+}
+function detectProjectConfig(projectRoot) {
+  const detector = new ProjectDetector(projectRoot);
+  return detector.detect();
+}
+var init_project_detector = () => {};
+
 // vendor/visualize/src/cli.ts
-import * as fs5 from "node:fs";
-import * as path5 from "node:path";
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
 
 // vendor/analysis/src/extract/architecture.ts
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
 
 // vendor/analysis/src/extract/manifest.ts
 import * as fs from "node:fs";
@@ -29,10 +464,14 @@ class ManifestParser {
   manifestPath;
   manifestData;
   baseDir;
-  constructor(projectRoot) {
+  constructor(projectRoot, optional = false) {
     this.baseDir = projectRoot;
     this.manifestPath = path.join(projectRoot, "manifest.json");
     if (!fs.existsSync(this.manifestPath)) {
+      if (optional) {
+        this.manifestData = null;
+        return;
+      }
       throw new Error(`manifest.json not found at ${this.manifestPath}`);
     }
     try {
@@ -42,7 +481,13 @@ class ManifestParser {
       throw new Error(`Failed to parse manifest.json: ${error}`);
     }
   }
+  hasManifest() {
+    return this.manifestData !== null;
+  }
   parse() {
+    if (!this.manifestData) {
+      throw new Error("Cannot parse manifest: manifest.json not loaded. Use hasManifest() to check availability.");
+    }
     const manifest = this.manifestData;
     return {
       name: manifest.name || "Unknown Extension",
@@ -59,6 +504,9 @@ class ManifestParser {
     };
   }
   getContextEntryPoints() {
+    if (!this.manifestData) {
+      return {};
+    }
     const entryPoints = {};
     const background = this.parseBackground();
     if (background) {
@@ -101,6 +549,8 @@ class ManifestParser {
     return entryPoints;
   }
   parseBackground() {
+    if (!this.manifestData)
+      return;
     const bg = this.manifestData.background;
     if (!bg)
       return;
@@ -125,6 +575,8 @@ class ManifestParser {
     return;
   }
   parseContentScripts() {
+    if (!this.manifestData)
+      return;
     const cs = this.manifestData.content_scripts;
     if (!cs || !Array.isArray(cs))
       return;
@@ -135,6 +587,8 @@ class ManifestParser {
     }));
   }
   parsePopup() {
+    if (!this.manifestData)
+      return;
     const action = this.manifestData.action || this.manifestData.browser_action;
     if (!action)
       return;
@@ -147,6 +601,8 @@ class ManifestParser {
     return;
   }
   parseOptions() {
+    if (!this.manifestData)
+      return;
     const options = this.manifestData.options_ui || this.manifestData.options_page;
     if (!options)
       return;
@@ -162,6 +618,8 @@ class ManifestParser {
     };
   }
   parseDevtools() {
+    if (!this.manifestData)
+      return;
     const devtools = this.manifestData.devtools_page;
     if (!devtools)
       return;
@@ -466,7 +924,34 @@ class FlowAnalyzer {
           const expression = node.getExpression();
           if (Node2.isPropertyAccessExpression(expression)) {
             const methodName = expression.getName();
-            if (methodName === "send" || methodName === "emit") {
+            if (methodName === "send" || methodName === "emit" || methodName === "postMessage" || methodName === "broadcast") {
+              const args = node.getArguments();
+              if (args.length > 0) {
+                const firstArg = args[0];
+                let msgType;
+                if (Node2.isStringLiteral(firstArg)) {
+                  msgType = firstArg.getLiteralValue();
+                } else if (Node2.isObjectLiteralExpression(firstArg)) {
+                  const typeProperty = firstArg.getProperty("type");
+                  if (typeProperty && Node2.isPropertyAssignment(typeProperty)) {
+                    const initializer = typeProperty.getInitializer();
+                    if (initializer && Node2.isStringLiteral(initializer)) {
+                      msgType = initializer.getLiteralValue();
+                    }
+                  }
+                }
+                if (msgType === messageType) {
+                  senders.push({
+                    context,
+                    file: filePath,
+                    line: node.getStartLineNumber()
+                  });
+                }
+              }
+            }
+          }
+          if (Node2.isIdentifier(expression)) {
+            if (expression.getText() === "postMessage") {
               const args = node.getArguments();
               if (args.length > 0) {
                 const firstArg = args[0];
@@ -618,6 +1103,15 @@ class FlowAnalyzer {
     if (path2.includes("/offscreen/") || path2.includes("\\offscreen\\")) {
       return "offscreen";
     }
+    if (path2.includes("/server/") || path2.includes("\\server\\") || path2.includes("/server.")) {
+      return "server";
+    }
+    if (path2.includes("/client/") || path2.includes("\\client\\") || path2.includes("/client.")) {
+      return "client";
+    }
+    if (path2.includes("/worker/") || path2.includes("\\worker\\") || path2.includes("service-worker")) {
+      return "worker";
+    }
     return "unknown";
   }
 }
@@ -854,7 +1348,7 @@ class HandlerExtractor {
         const expression = node.getExpression();
         if (Node4.isPropertyAccessExpression(expression)) {
           const methodName = expression.getName();
-          if (methodName === "on") {
+          if (methodName === "on" || methodName === "addEventListener") {
             const handler = this.extractHandler(node, context, filePath);
             if (handler) {
               handlers.push(handler);
@@ -862,6 +1356,14 @@ class HandlerExtractor {
           }
         }
       }
+      if (Node4.isSwitchStatement(node)) {
+        const switchHandlers = this.extractSwitchCaseHandlers(node, context, filePath);
+        handlers.push(...switchHandlers);
+      }
+      if (Node4.isVariableDeclaration(node)) {
+        const mapHandlers = this.extractHandlerMapPattern(node, context, filePath);
+        handlers.push(...mapHandlers);
+      }
     });
     return handlers;
   }
@@ -1003,6 +1505,75 @@ class HandlerExtractor {
     }
     return;
   }
+  extractSwitchCaseHandlers(switchNode, context, filePath) {
+    const handlers = [];
+    try {
+      const expression = switchNode.getExpression();
+      const expressionText = expression.getText();
+      if (!/\.(type|kind|event|action)/.test(expressionText)) {
+        return handlers;
+      }
+      const caseClauses = switchNode.getClauses();
+      for (const clause of caseClauses) {
+        if (Node4.isCaseClause(clause)) {
+          const caseExpr = clause.getExpression();
+          let messageType = null;
+          if (Node4.isStringLiteral(caseExpr)) {
+            messageType = caseExpr.getLiteralValue();
+          }
+          if (messageType) {
+            const line = clause.getStartLineNumber();
+            handlers.push({
+              messageType,
+              node: context,
+              assignments: [],
+              preconditions: [],
+              postconditions: [],
+              location: { file: filePath, line }
+            });
+          }
+        }
+      }
+    } catch (error) {}
+    return handlers;
+  }
+  extractHandlerMapPattern(varDecl, context, filePath) {
+    const handlers = [];
+    try {
+      const initializer = varDecl.getInitializer();
+      if (!initializer || !Node4.isObjectLiteralExpression(initializer)) {
+        return handlers;
+      }
+      const varName = varDecl.getName().toLowerCase();
+      if (!/(handler|listener|callback|event)s?/.test(varName)) {
+        return handlers;
+      }
+      const properties = initializer.getProperties();
+      for (const prop of properties) {
+        if (Node4.isPropertyAssignment(prop)) {
+          const nameNode = prop.getNameNode();
+          let messageType = null;
+          if (Node4.isStringLiteral(nameNode)) {
+            messageType = nameNode.getLiteralValue();
+          } else if (Node4.isIdentifier(nameNode)) {
+            messageType = nameNode.getText();
+          }
+          if (messageType) {
+            const line = prop.getStartLineNumber();
+            handlers.push({
+              messageType,
+              node: context,
+              assignments: [],
+              preconditions: [],
+              postconditions: [],
+              location: { file: filePath, line }
+            });
+          }
+        }
+      }
+    } catch (error) {}
+    return handlers;
+  }
   inferContext(filePath) {
     const path2 = filePath.toLowerCase();
     if (path2.includes("/background/") || path2.includes("\\background\\")) {
@@ -1023,6 +1594,15 @@ class HandlerExtractor {
     if (path2.includes("/offscreen/") || path2.includes("\\offscreen\\")) {
       return "offscreen";
     }
+    if (path2.includes("/server/") || path2.includes("\\server\\") || path2.includes("/server.")) {
+      return "server";
+    }
+    if (path2.includes("/client/") || path2.includes("\\client\\") || path2.includes("/client.")) {
+      return "client";
+    }
+    if (path2.includes("/worker/") || path2.includes("\\worker\\") || path2.includes("service-worker")) {
+      return "worker";
+    }
     return "unknown";
   }
 }
@@ -1168,9 +1748,29 @@ class ArchitectureAnalyzer {
     this.options = options;
   }
   async analyze() {
-    const manifestParser = new ManifestParser(this.options.projectRoot);
-    const manifest = manifestParser.parse();
-    const entryPoints = manifestParser.getContextEntryPoints();
+    let manifest;
+    let projectConfig;
+    let entryPoints = {};
+    let systemInfo;
+    const manifestParser = new ManifestParser(this.options.projectRoot, true);
+    if (manifestParser.hasManifest() && !this.options.useProjectDetector) {
+      manifest = manifestParser.parse();
+      entryPoints = manifestParser.getContextEntryPoints();
+      systemInfo = {
+        name: manifest.name,
+        version: manifest.version,
+        description: manifest.description
+      };
+    } else {
+      const { detectProjectConfig: detectProjectConfig2 } = await Promise.resolve().then(() => (init_project_detector(), exports_project_detector));
+      projectConfig = detectProjectConfig2(this.options.projectRoot);
+      entryPoints = projectConfig.entryPoints;
+      systemInfo = {
+        name: projectConfig.metadata?.name || "Unknown Project",
+        version: projectConfig.metadata?.version || "0.0.0",
+        description: projectConfig.metadata?.description
+      };
+    }
     const handlerExtractor = new HandlerExtractor(this.options.tsConfigPath);
     const { handlers } = handlerExtractor.extractHandlers();
     const contextAnalyzer = new ContextAnalyzer(this.options.tsConfigPath);
@@ -1191,12 +1791,9 @@ class ArchitectureAnalyzer {
     const adrs = extractADRs(this.options.projectRoot);
     const repository = this.extractRepositoryInfo();
     return {
-      system: {
-        name: manifest.name,
-        version: manifest.version,
-        description: manifest.description
-      },
+      system: systemInfo,
       manifest,
+      projectConfig,
       contexts,
       messageFlows,
       integrations,
@@ -1219,12 +1816,12 @@ class ArchitectureAnalyzer {
     }
   }
   extractRepositoryInfo() {
-    const packageJsonPath = path3.join(this.options.projectRoot, "package.json");
-    if (!fs3.existsSync(packageJsonPath)) {
+    const packageJsonPath = path4.join(this.options.projectRoot, "package.json");
+    if (!fs4.existsSync(packageJsonPath)) {
       return;
     }
     try {
-      const content = fs3.readFileSync(packageJsonPath, "utf-8");
+      const content = fs4.readFileSync(packageJsonPath, "utf-8");
       const packageJson = JSON.parse(content);
       if (packageJson.repository) {
         if (typeof packageJson.repository === "string") {
@@ -1724,8 +2321,8 @@ function generateStructurizrDSL(analysis, options) {
 }
 
 // vendor/visualize/src/runner/export.ts
-import * as fs4 from "node:fs";
-import * as path4 from "node:path";
+import * as fs5 from "node:fs";
+import * as path5 from "node:path";
 import { spawn } from "node:child_process";
 
 class DiagramExporter {
@@ -1733,15 +2330,15 @@ class DiagramExporter {
   static DEFAULT_TIMEOUT = 120000;
   async export(options) {
     const { dslPath, outputDir, timeout = DiagramExporter.DEFAULT_TIMEOUT } = options;
-    if (!fs4.existsSync(dslPath)) {
+    if (!fs5.existsSync(dslPath)) {
       return {
         success: false,
         siteDir: "",
         error: `DSL file not found: ${dslPath}`
       };
     }
-    if (!fs4.existsSync(outputDir)) {
-      fs4.mkdirSync(outputDir, { recursive: true });
+    if (!fs5.existsSync(outputDir)) {
+      fs5.mkdirSync(outputDir, { recursive: true });
     }
     const dockerAvailable = await this.isDockerAvailable();
     if (!dockerAvailable) {
@@ -1774,8 +2371,8 @@ class DiagramExporter {
     }
   }
   async exportStaticSite(dslPath, outputDir, timeout) {
-    const dslDir = path4.dirname(dslPath);
-    const dslFileName = path4.basename(dslPath);
+    const dslDir = path5.dirname(dslPath);
+    const dslFileName = path5.basename(dslPath);
     const workspaceMount = `${dslDir}:/usr/local/structurizr`;
     const outputMount = `${outputDir}:/output`;
     const args = [
@@ -1813,7 +2410,7 @@ class DiagramExporter {
     }
   }
   async pullImage(onProgress) {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const proc = spawn("docker", ["pull", DiagramExporter.DOCKER_IMAGE]);
       proc.stdout.on("data", (data) => {
         onProgress?.(data.toString().trim());
@@ -1823,7 +2420,7 @@ class DiagramExporter {
       });
       proc.on("close", (code) => {
         if (code === 0) {
-          resolve2();
+          resolve3();
         } else {
           reject(new Error(`Failed to pull image, exit code: ${code}`));
         }
@@ -1837,7 +2434,7 @@ class DiagramExporter {
     return this.runCommand("docker", args, timeout);
   }
   async runCommand(command, args, timeout) {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const proc = spawn(command, args);
       let stdout = "";
       let stderr = "";
@@ -1854,7 +2451,7 @@ class DiagramExporter {
       proc.on("close", (code) => {
         clearTimeout(timer);
         if (code === 0) {
-          resolve2(stdout);
+          resolve3(stdout);
         } else {
           reject(new Error(`Command failed with exit code ${code}: ${stderr}`));
         }
@@ -1923,11 +2520,17 @@ async function generateCommand() {
     console.log(color(`   Using: ${tsConfigPath}`, COLORS.gray));
     const projectRoot = findProjectRoot();
     if (!projectRoot) {
-      console.error(color("❌ Could not find manifest.json", COLORS.red));
-      console.error("   Run this command from your extension project root");
+      console.error(color("❌ Could not find project root", COLORS.red));
+      console.error("   Run this command from a directory with manifest.json, package.json, or tsconfig.json");
       process.exit(1);
     }
     console.log(color(`   Project: ${projectRoot}`, COLORS.gray));
+    const hasManifest = fs6.existsSync(path6.join(projectRoot, "manifest.json"));
+    if (hasManifest) {
+      console.log(color(`   Type: Chrome Extension`, COLORS.gray));
+    } else {
+      console.log(color(`   Type: Detecting from project structure...`, COLORS.gray));
+    }
     const analysis = await analyzeArchitecture({
       tsConfigPath,
       projectRoot
@@ -1963,12 +2566,12 @@ async function generateCommand() {
       includeComponentDiagrams: true,
       componentDiagramContexts: ["background"]
     });
-    const outputDir = path5.join(process.cwd(), "docs");
-    if (!fs5.existsSync(outputDir)) {
-      fs5.mkdirSync(outputDir, { recursive: true });
+    const outputDir = path6.join(process.cwd(), "docs");
+    if (!fs6.existsSync(outputDir)) {
+      fs6.mkdirSync(outputDir, { recursive: true });
     }
-    const dslPath = path5.join(outputDir, "architecture.dsl");
-    fs5.writeFileSync(dslPath, dsl, "utf-8");
+    const dslPath = path6.join(outputDir, "architecture.dsl");
+    fs6.writeFileSync(dslPath, dsl, "utf-8");
     console.log(color(`✅ Architecture documentation generated!
 `, COLORS.green));
     console.log(`   File: ${color(dslPath, COLORS.blue)}`);
@@ -2010,14 +2613,14 @@ async function exportCommand(args) {
 \uD83D\uDCE4 Generating static site...
 `, COLORS.blue));
   try {
-    const dslPath = path5.join(process.cwd(), "docs", "architecture.dsl");
-    if (!fs5.existsSync(dslPath)) {
+    const dslPath = path6.join(process.cwd(), "docs", "architecture.dsl");
+    if (!fs6.existsSync(dslPath)) {
       console.error(color("❌ DSL file not found", COLORS.red));
       console.error("   Expected: docs/architecture.dsl");
       console.error("   Run 'bun visualize' first to generate the DSL");
       process.exit(1);
     }
-    const outputDir = path5.join(process.cwd(), "docs", "site");
+    const outputDir = path6.join(process.cwd(), "docs", "site");
     console.log(color(`   DSL: ${dslPath}`, COLORS.gray));
     console.log(color(`   Output: ${outputDir}`, COLORS.gray));
     console.log();
@@ -2061,9 +2664,9 @@ async function serveCommand(args) {
 \uD83C\uDF10 Starting static site server...
 `, COLORS.blue));
   try {
-    const siteDir = path5.join(process.cwd(), "docs", "site");
-    const indexPath = path5.join(siteDir, "index.html");
-    if (!fs5.existsSync(indexPath)) {
+    const siteDir = path6.join(process.cwd(), "docs", "site");
+    const indexPath = path6.join(siteDir, "index.html");
+    if (!fs6.existsSync(indexPath)) {
       console.error(color("❌ Static site not found", COLORS.red));
       console.error("   Expected: docs/site/index.html");
       console.error("   Run 'bun visualize --export' first to generate the site");
@@ -2082,8 +2685,8 @@ async function serveCommand(args) {
       port,
       fetch(req) {
         const url = new URL(req.url);
-        let filePath = path5.join(siteDir, url.pathname === "/" ? "index.html" : url.pathname);
-        if (fs5.existsSync(filePath) && fs5.statSync(filePath).isFile()) {
+        let filePath = path6.join(siteDir, url.pathname === "/" ? "index.html" : url.pathname);
+        if (fs6.existsSync(filePath) && fs6.statSync(filePath).isFile()) {
           const file = BunGlobal.file(filePath);
           return new Response(file);
         }
@@ -2114,7 +2717,15 @@ async function serveCommand(args) {
 }
 function showHelp() {
   console.log(`
-${color("bun visualize", COLORS.blue)} - Architecture visualization for web extensions
+${color("bun visualize", COLORS.blue)} - Architecture visualization tool
+
+${color("Supports:", COLORS.blue)}
+
+  • Chrome Extensions (manifest.json)
+  • PWAs (public/manifest.json)
+  • WebSocket/Server Apps (ws, socket.io, elysia)
+  • Electron Apps
+  • Generic TypeScript Projects
 
 ${color("Commands:", COLORS.blue)}
 
@@ -2134,14 +2745,14 @@ ${color("Commands:", COLORS.blue)}
 
 ${color("Getting Started:", COLORS.blue)}
 
-  1. Run ${color("bun visualize", COLORS.green)} from your extension project root
+  1. Run ${color("bun visualize", COLORS.green)} from your project root
   2. Find generated ${color("docs/architecture.dsl", COLORS.blue)}
   3. View with Structurizr Lite (see instructions after generation)
 
 ${color("What gets generated:", COLORS.blue)}
 
-  • System Context diagram - Extension + external systems
-  • Container diagram - Extension contexts (background, content, popup, etc.)
+  • System Context diagram - Your app + external systems
+  • Container diagram - App contexts (background, content, server, client, etc.)
   • Component diagrams - Internal components within contexts
   • Dynamic diagrams - Message flows between contexts
 
@@ -2154,21 +2765,20 @@ ${color("Learn More:", COLORS.blue)}
 }
 function findTsConfig() {
   const locations = [
-    path5.join(process.cwd(), "tsconfig.json"),
-    path5.join(process.cwd(), "..", "tsconfig.json")
+    path6.join(process.cwd(), "tsconfig.json"),
+    path6.join(process.cwd(), "..", "tsconfig.json")
   ];
   for (const loc of locations) {
-    if (fs5.existsSync(loc)) {
+    if (fs6.existsSync(loc)) {
       return loc;
     }
   }
   return null;
 }
 function findProjectRoot() {
-  const locations = [process.cwd(), path5.join(process.cwd(), "..")];
+  const locations = [process.cwd(), path6.join(process.cwd(), "..")];
   for (const loc of locations) {
-    const manifestPath = path5.join(loc, "manifest.json");
-    if (fs5.existsSync(manifestPath)) {
+    if (fs6.existsSync(path6.join(loc, "manifest.json")) || fs6.existsSync(path6.join(loc, "package.json")) || fs6.existsSync(path6.join(loc, "tsconfig.json"))) {
       return loc;
     }
   }
@@ -2186,4 +2796,4 @@ Stack trace:`, COLORS.gray));
   process.exit(1);
 });
 
-//# debugId=3B56BF342A9A6DCB64756E2164756E21
+//# debugId=37FBF573C9C57A4C64756E2164756E21