@fairfox/polly 0.2.0 → 0.2.1

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

@@ -13,13 +13,327 @@ 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);
+      }
+      if (packageJson.dependencies?.ws || packageJson.dependencies?.["socket.io"] || packageJson.dependencies?.elysia || packageJson.dependencies?.express) {
+        return this.detectWebSocketApp(packageJson);
+      }
+    }
+    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 serverCandidates = [
+      "src/server.ts",
+      "src/index.ts",
+      "src/main.ts",
+      "src/app.ts",
+      "server.ts",
+      "index.ts"
+    ];
+    for (const candidate of serverCandidates) {
+      const fullPath = path3.join(this.projectRoot, candidate);
+      if (fs3.existsSync(fullPath)) {
+        entryPoints.server = fullPath;
+        break;
+      }
+    }
+    const clientCandidates = [
+      "src/client/index.ts",
+      "src/client.ts",
+      "client/index.ts"
+    ];
+    for (const candidate of clientCandidates) {
+      const fullPath = path3.join(this.projectRoot, candidate);
+      if (fs3.existsSync(fullPath)) {
+        entryPoints.client = fullPath;
+        break;
+      }
+    }
+    return {
+      type: "websocket-app",
+      entryPoints,
+      contextMapping: {
+        server: "Server",
+        client: "Client"
+      },
+      metadata: {
+        name: packageJson.name,
+        version: packageJson.version,
+        description: packageJson.description
+      }
+    };
+  }
+  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";
@@ -1168,9 +1482,31 @@ 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 manifestPath = path4.join(this.options.projectRoot, "manifest.json");
+    const hasManifest = fs4.existsSync(manifestPath);
+    if (hasManifest && !this.options.useProjectDetector) {
+      const manifestParser = new ManifestParser(this.options.projectRoot);
+      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 +1527,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 +1552,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 +2057,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 +2066,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 +2107,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 +2146,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 +2156,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 +2170,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 +2187,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}`));
         }
@@ -1963,12 +2296,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 +2343,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 +2394,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 +2415,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);
         }
@@ -2154,21 +2487,21 @@ ${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)) {
+    const manifestPath = path6.join(loc, "manifest.json");
+    if (fs6.existsSync(manifestPath)) {
       return loc;
     }
   }
@@ -2186,4 +2519,4 @@ Stack trace:`, COLORS.gray));
   process.exit(1);
 });
 
-//# debugId=3B56BF342A9A6DCB64756E2164756E21
+//# debugId=42A0D5368C5C715B64756E2164756E21