@fairfox/polly 0.1.3 → 0.1.4

package/vendor/analysis/src/extract/integrations.ts

@@ -1,329 +0,0 @@
-// External integration detection - find external APIs, services, etc.
-
-import { Project, Node } from "ts-morph";
-import type { ExternalIntegration, ExternalAPICall } from "../types/architecture";
-
-export class IntegrationAnalyzer {
-  private project: Project;
-
-  constructor(tsConfigPath: string) {
-    this.project = new Project({
-      tsConfigFilePath: tsConfigPath,
-    });
-  }
-
-  /**
-   * Analyze external integrations in the codebase
-   */
-  analyzeIntegrations(): ExternalIntegration[] {
-    const integrations = new Map<string, ExternalIntegration>();
-
-    // Find all fetch() calls
-    const fetchCalls = this.findFetchCalls();
-    for (const call of fetchCalls) {
-      this.addOrMergeIntegration(integrations, this.createAPIIntegration(call));
-    }
-
-    // Find WebSocket connections
-    const websockets = this.findWebSockets();
-    for (const ws of websockets) {
-      this.addOrMergeIntegration(integrations, this.createWebSocketIntegration(ws));
-    }
-
-    // Find external script imports
-    const externalScripts = this.findExternalScripts();
-    for (const script of externalScripts) {
-      this.addOrMergeIntegration(integrations, script);
-    }
-
-    return Array.from(integrations.values());
-  }
-
-  /**
-   * Find all fetch() API calls
-   */
-  private findFetchCalls(): Array<{
-    url: string;
-    method: string;
-    file: string;
-    line: number;
-    description?: string;
-  }> {
-    const calls: Array<{
-      url: string;
-      method: string;
-      file: string;
-      line: number;
-      description?: string;
-    }> = [];
-
-    for (const sourceFile of this.project.getSourceFiles()) {
-      sourceFile.forEachDescendant((node) => {
-        if (Node.isCallExpression(node)) {
-          const expression = node.getExpression();
-
-          // Check for fetch() calls
-          if (Node.isIdentifier(expression) && expression.getText() === "fetch") {
-            const args = node.getArguments();
-            if (args.length > 0) {
-              // Extract URL
-              const urlArg = args[0];
-              let url: string | null = null;
-
-              if (Node.isStringLiteral(urlArg)) {
-                url = urlArg.getLiteralValue();
-              } else if (Node.isTemplateExpression(urlArg)) {
-                // Try to extract base URL from template
-                url = this.extractBaseURL(urlArg.getText());
-              }
-
-              if (url) {
-                // Extract method
-                let method = "GET"; // Default
-                if (args.length > 1 && Node.isObjectLiteralExpression(args[1])) {
-                  const options = args[1];
-                  const methodProp = options.getProperty("method");
-                  if (methodProp && Node.isPropertyAssignment(methodProp)) {
-                    const initializer = methodProp.getInitializer();
-                    if (initializer && Node.isStringLiteral(initializer)) {
-                      method = initializer.getLiteralValue().toUpperCase();
-                    }
-                  }
-                }
-
-                // Extract description from JSDoc
-                const description = this.extractJSDocDescription(node);
-
-                calls.push({
-                  url,
-                  method,
-                  file: sourceFile.getFilePath(),
-                  line: node.getStartLineNumber(),
-                  description,
-                });
-              }
-            }
-          }
-        }
-      });
-    }
-
-    return calls;
-  }
-
-  /**
-   * Find WebSocket connections
-   */
-  private findWebSockets(): Array<{
-    url: string;
-    file: string;
-    line: number;
-    description?: string;
-  }> {
-    const websockets: Array<{
-      url: string;
-      file: string;
-      line: number;
-      description?: string;
-    }> = [];
-
-    for (const sourceFile of this.project.getSourceFiles()) {
-      sourceFile.forEachDescendant((node) => {
-        if (Node.isNewExpression(node)) {
-          const expression = node.getExpression();
-
-          // Check for new WebSocket()
-          if (Node.isIdentifier(expression) && expression.getText() === "WebSocket") {
-            const args = node.getArguments();
-            if (args.length > 0 && Node.isStringLiteral(args[0])) {
-              const url = args[0].getLiteralValue();
-              const description = this.extractJSDocDescription(node);
-
-              websockets.push({
-                url,
-                file: sourceFile.getFilePath(),
-                line: node.getStartLineNumber(),
-                description,
-              });
-            }
-          }
-        }
-      });
-    }
-
-    return websockets;
-  }
-
-  /**
-   * Find external script dependencies (from imports)
-   */
-  private findExternalScripts(): ExternalIntegration[] {
-    const scripts: ExternalIntegration[] = [];
-    const seen = new Set<string>();
-
-    for (const sourceFile of this.project.getSourceFiles()) {
-      for (const importDecl of sourceFile.getImportDeclarations()) {
-        const moduleSpecifier = importDecl.getModuleSpecifierValue();
-
-        // Only consider external packages (not relative imports)
-        if (!moduleSpecifier.startsWith(".") && !moduleSpecifier.startsWith("/")) {
-          // Extract package name (handle scoped packages)
-          const packageName = moduleSpecifier.startsWith("@")
-            ? moduleSpecifier.split("/").slice(0, 2).join("/")
-            : moduleSpecifier.split("/")[0];
-
-          if (!seen.has(packageName)) {
-            seen.add(packageName);
-
-            scripts.push({
-              type: "external-script",
-              name: packageName,
-              technology: "npm package",
-              usedIn: [sourceFile.getFilePath()],
-              description: `External dependency: ${packageName}`,
-            });
-          }
-        }
-      }
-    }
-
-    return scripts;
-  }
-
-  /**
-   * Create API integration from fetch call
-   */
-  private createAPIIntegration(call: {
-    url: string;
-    method: string;
-    file: string;
-    line: number;
-    description?: string;
-  }): ExternalIntegration {
-    // Extract base URL
-    const baseURL = this.extractBaseURL(call.url);
-
-    // Infer name from URL
-    const name = this.inferAPIName(baseURL);
-
-    return {
-      type: "api",
-      name,
-      technology: "REST API",
-      url: baseURL,
-      usedIn: [call.file],
-      description: call.description || `External API: ${name}`,
-      calls: [
-        {
-          method: call.method,
-          endpoint: call.url,
-          location: {
-            file: call.file,
-            line: call.line,
-          },
-          description: call.description,
-        },
-      ],
-    };
-  }
-
-  /**
-   * Create WebSocket integration
-   */
-  private createWebSocketIntegration(ws: {
-    url: string;
-    file: string;
-    line: number;
-    description?: string;
-  }): ExternalIntegration {
-    const name = this.inferAPIName(ws.url);
-
-    return {
-      type: "websocket",
-      name,
-      technology: "WebSocket",
-      url: ws.url,
-      usedIn: [ws.file],
-      description: ws.description || `WebSocket connection: ${name}`,
-    };
-  }
-
-  /**
-   * Extract base URL from full URL or template
-   */
-  private extractBaseURL(url: string): string {
-    // Remove template parts
-    url = url.replace(/\$\{[^}]+\}/g, "");
-    url = url.replace(/`/g, "");
-
-    try {
-      const parsed = new URL(url);
-      return `${parsed.protocol}//${parsed.host}`;
-    } catch {
-      // If parsing fails, try to extract domain
-      const match = url.match(/https?:\/\/([^/]+)/);
-      return match ? match[0] : url;
-    }
-  }
-
-  /**
-   * Infer API name from URL
-   */
-  private inferAPIName(url: string): string {
-    try {
-      const parsed = new URL(url);
-      const hostname = parsed.hostname;
-
-      // Remove www. prefix
-      const cleanHost = hostname.replace(/^www\./, "");
-
-      // Take first part of domain
-      const parts = cleanHost.split(".");
-      if (parts.length > 0) {
-        // Capitalize first letter
-        return parts[0].charAt(0).toUpperCase() + parts[0].slice(1) + " API";
-      }
-    } catch {
-      // Fallback
-    }
-
-    return "External API";
-  }
-
-  /**
-   * Add or merge integration into map
-   */
-  private addOrMergeIntegration(
-    map: Map<string, ExternalIntegration>,
-    integration: ExternalIntegration
-  ): void {
-    const key = `${integration.type}:${integration.name}`;
-
-    if (map.has(key)) {
-      const existing = map.get(key)!;
-
-      // Merge usedIn
-      existing.usedIn = [...new Set([...existing.usedIn, ...integration.usedIn])];
-
-      // Merge calls
-      if (integration.calls && existing.calls) {
-        existing.calls.push(...integration.calls);
-      } else if (integration.calls) {
-        existing.calls = integration.calls;
-      }
-    } else {
-      map.set(key, integration);
-    }
-  }
-
-  /**
-   * Extract JSDoc description from node
-   */
-  private extractJSDocDescription(node: any): string | undefined {
-    const jsDocs = node.getJsDocs?.() || [];
-    if (jsDocs.length === 0) return undefined;
-
-    const comment = jsDocs[0].getDescription().trim();
-    return comment || undefined;
-  }
-}

package/vendor/analysis/src/extract/manifest.ts

@@ -1,298 +0,0 @@
-// Manifest.json parser for Chrome extensions
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { ManifestInfo, ContextInfo } from "../types/architecture";
-
-/**
- * Parse manifest.json and extract context information
- */
-export class ManifestParser {
-  private manifestPath: string;
-  private manifestData: any;
-  private baseDir: string;
-
-  constructor(projectRoot: string) {
-    this.baseDir = projectRoot;
-    this.manifestPath = path.join(projectRoot, "manifest.json");
-
-    if (!fs.existsSync(this.manifestPath)) {
-      throw new Error(`manifest.json not found at ${this.manifestPath}`);
-    }
-
-    try {
-      const content = fs.readFileSync(this.manifestPath, "utf-8");
-      this.manifestData = JSON.parse(content);
-    } catch (error) {
-      throw new Error(`Failed to parse manifest.json: ${error}`);
-    }
-  }
-
-  /**
-   * Parse manifest and extract all information
-   */
-  parse(): ManifestInfo {
-    const manifest = this.manifestData;
-
-    return {
-      name: manifest.name || "Unknown Extension",
-      version: manifest.version || "0.0.0",
-      description: manifest.description,
-      manifestVersion: manifest.manifest_version || 2,
-      background: this.parseBackground(),
-      contentScripts: this.parseContentScripts(),
-      popup: this.parsePopup(),
-      options: this.parseOptions(),
-      devtools: this.parseDevtools(),
-      permissions: manifest.permissions || [],
-      hostPermissions: manifest.host_permissions || [],
-    };
-  }
-
-  /**
-   * Get context entry points from manifest
-   */
-  getContextEntryPoints(): Record<string, string> {
-    const entryPoints: Record<string, string> = {};
-
-    // Background
-    const background = this.parseBackground();
-    if (background) {
-      // Take first file as entry point
-      const entryFile = background.files[0];
-      if (entryFile) {
-        entryPoints.background = this.findSourceFile(entryFile);
-      }
-    }
-
-    // Content scripts
-    const contentScripts = this.parseContentScripts();
-    if (contentScripts && contentScripts.length > 0) {
-      const firstScript = contentScripts[0].js[0];
-      if (firstScript) {
-        entryPoints.content = this.findSourceFile(firstScript);
-      }
-    }
-
-    // Popup
-    const popup = this.parsePopup();
-    if (popup) {
-      // For HTML, we need to find the associated JS/TS file
-      const htmlPath = path.join(this.baseDir, popup.html);
-      const jsPath = this.findAssociatedJS(htmlPath);
-      if (jsPath) {
-        entryPoints.popup = jsPath;
-      }
-    }
-
-    // Options
-    const options = this.parseOptions();
-    if (options) {
-      const htmlPath = path.join(this.baseDir, options.page);
-      const jsPath = this.findAssociatedJS(htmlPath);
-      if (jsPath) {
-        entryPoints.options = jsPath;
-      }
-    }
-
-    // DevTools
-    const devtools = this.parseDevtools();
-    if (devtools) {
-      const htmlPath = path.join(this.baseDir, devtools.page);
-      const jsPath = this.findAssociatedJS(htmlPath);
-      if (jsPath) {
-        entryPoints.devtools = jsPath;
-      }
-    }
-
-    return entryPoints;
-  }
-
-  /**
-   * Parse background configuration
-   */
-  private parseBackground(): ManifestInfo["background"] {
-    const bg = this.manifestData.background;
-    if (!bg) return undefined;
-
-    // Manifest V3 - service worker
-    if (bg.service_worker) {
-      return {
-        type: "service_worker",
-        files: [bg.service_worker],
-      };
-    }
-
-    // Manifest V2 - scripts
-    if (bg.scripts) {
-      return {
-        type: "script",
-        files: bg.scripts,
-      };
-    }
-
-    // Manifest V2 - page
-    if (bg.page) {
-      return {
-        type: "script",
-        files: [bg.page],
-      };
-    }
-
-    return undefined;
-  }
-
-  /**
-   * Parse content scripts configuration
-   */
-  private parseContentScripts(): ManifestInfo["contentScripts"] {
-    const cs = this.manifestData.content_scripts;
-    if (!cs || !Array.isArray(cs)) return undefined;
-
-    return cs.map((script) => ({
-      matches: script.matches || [],
-      js: script.js || [],
-      css: script.css,
-    }));
-  }
-
-  /**
-   * Parse popup configuration
-   */
-  private parsePopup(): ManifestInfo["popup"] {
-    const action = this.manifestData.action || this.manifestData.browser_action;
-    if (!action) return undefined;
-
-    if (action.default_popup) {
-      return {
-        html: action.default_popup,
-        default: true,
-      };
-    }
-
-    return undefined;
-  }
-
-  /**
-   * Parse options configuration
-   */
-  private parseOptions(): ManifestInfo["options"] {
-    const options = this.manifestData.options_ui || this.manifestData.options_page;
-    if (!options) return undefined;
-
-    if (typeof options === "string") {
-      return {
-        page: options,
-        openInTab: false,
-      };
-    }
-
-    return {
-      page: options.page,
-      openInTab: options.open_in_tab,
-    };
-  }
-
-  /**
-   * Parse devtools configuration
-   */
-  private parseDevtools(): ManifestInfo["devtools"] {
-    const devtools = this.manifestData.devtools_page;
-    if (!devtools) return undefined;
-
-    return {
-      page: devtools,
-    };
-  }
-
-  /**
-   * Find source file from manifest reference
-   * Tries multiple locations: exact path, src/ directory, .ts extension
-   */
-  private findSourceFile(manifestPath: string): string {
-    const candidates = [
-      // Exact path from manifest
-      path.join(this.baseDir, manifestPath),
-      // Same path with .ts extension
-      path.join(this.baseDir, manifestPath.replace(/\.js$/, ".ts")),
-      // In src/ directory
-      path.join(this.baseDir, "src", manifestPath),
-      path.join(this.baseDir, "src", manifestPath.replace(/\.js$/, ".ts")),
-      // In src/ with .tsx extension
-      path.join(this.baseDir, "src", manifestPath.replace(/\.js$/, ".tsx")),
-    ];
-
-    for (const candidate of candidates) {
-      if (fs.existsSync(candidate)) {
-        return candidate;
-      }
-    }
-
-    // Fallback to manifest path (will error later if not found)
-    return path.join(this.baseDir, manifestPath);
-  }
-
-  /**
-   * Find associated JavaScript/TypeScript file for an HTML file
-   */
-  private findAssociatedJS(htmlPath: string): string | null {
-    if (!fs.existsSync(htmlPath)) {
-      return null;
-    }
-
-    // Read HTML and look for script tags
-    const html = fs.readFileSync(htmlPath, "utf-8");
-    const scriptMatch = html.match(/<script[^>]+src=["']([^"']+)["']/i);
-
-    if (scriptMatch && scriptMatch[1]) {
-      const scriptPath = scriptMatch[1];
-      const fullPath = path.resolve(path.dirname(htmlPath), scriptPath);
-
-      // Try with and without .js/.ts extension
-      if (fs.existsSync(fullPath)) return fullPath;
-      if (fs.existsSync(fullPath.replace(/\.js$/, ".ts"))) {
-        return fullPath.replace(/\.js$/, ".ts");
-      }
-      if (fs.existsSync(fullPath.replace(/\.js$/, ".tsx"))) {
-        return fullPath.replace(/\.js$/, ".tsx");
-      }
-    }
-
-    // Fallback: look for convention-based files
-    const baseName = path.basename(htmlPath, ".html");
-    const dir = path.dirname(htmlPath);
-
-    const candidates = [
-      path.join(dir, `${baseName}.ts`),
-      path.join(dir, `${baseName}.tsx`),
-      path.join(dir, `${baseName}.js`),
-      path.join(dir, "index.ts"),
-      path.join(dir, "index.tsx"),
-      path.join(dir, "index.js"),
-    ];
-
-    for (const candidate of candidates) {
-      if (fs.existsSync(candidate)) {
-        return candidate;
-      }
-    }
-
-    return null;
-  }
-}
-
-/**
- * Parse manifest.json and extract information
- */
-export function parseManifest(projectRoot: string): ManifestInfo {
-  const parser = new ManifestParser(projectRoot);
-  return parser.parse();
-}
-
-/**
- * Get context entry points from manifest.json
- */
-export function getContextEntryPoints(projectRoot: string): Record<string, string> {
-  const parser = new ManifestParser(projectRoot);
-  return parser.getContextEntryPoints();
-}