@fairfox/polly 0.1.2 → 0.1.4

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

@@ -1,309 +0,0 @@
-// Message flow analysis - trace messages between contexts
-
-import { Project, Node } from "ts-morph";
-import type { MessageFlow, MessageStep } from "../types/architecture";
-import type { MessageHandler } from "../types/core";
-
-export class FlowAnalyzer {
-  private project: Project;
-  private handlers: MessageHandler[];
-
-  constructor(tsConfigPath: string, handlers: MessageHandler[]) {
-    this.project = new Project({
-      tsConfigFilePath: tsConfigPath,
-    });
-    this.handlers = handlers;
-  }
-
-  /**
-   * Analyze message flows between contexts
-   */
-  analyzeFlows(): MessageFlow[] {
-    const flows: MessageFlow[] = [];
-
-    // Group handlers by message type
-    const handlersByType = new Map<string, MessageHandler[]>();
-    for (const handler of this.handlers) {
-      if (!handlersByType.has(handler.messageType)) {
-        handlersByType.set(handler.messageType, []);
-      }
-      handlersByType.get(handler.messageType)!.push(handler);
-    }
-
-    // For each message type, trace the flow
-    for (const [messageType, handlers] of handlersByType) {
-      // Find senders
-      const senders = this.findMessageSenders(messageType);
-
-      // For each sender, create a flow
-      for (const sender of senders) {
-        const recipients = handlers.map((h) => h.node);
-
-        // Build sequence of steps
-        const sequence = this.buildSequence(messageType, sender, handlers);
-
-        // Extract flow metadata
-        const flowMetadata = this.extractFlowMetadata(sender.file, sender.line);
-
-        flows.push({
-          messageType,
-          from: sender.context,
-          to: recipients,
-          trigger: flowMetadata.trigger,
-          flowName: flowMetadata.flowName,
-          description: flowMetadata.description,
-          sequence,
-        });
-      }
-    }
-
-    return flows;
-  }
-
-  /**
-   * Find all places where a message is sent
-   */
-  private findMessageSenders(messageType: string): Array<{
-    context: string;
-    file: string;
-    line: number;
-  }> {
-    const senders: Array<{ context: string; file: string; line: number }> = [];
-
-    for (const sourceFile of this.project.getSourceFiles()) {
-      const filePath = sourceFile.getFilePath();
-      const context = this.inferContext(filePath);
-
-      sourceFile.forEachDescendant((node) => {
-        if (Node.isCallExpression(node)) {
-          const expression = node.getExpression();
-
-          // Check for .send() or .emit() calls
-          if (Node.isPropertyAccessExpression(expression)) {
-            const methodName = expression.getName();
-
-            if (methodName === "send" || methodName === "emit") {
-              const args = node.getArguments();
-              if (args.length > 0) {
-                const firstArg = args[0];
-
-                let msgType: string | undefined;
-
-                // Check if first argument is a string literal: send("MESSAGE")
-                if (Node.isStringLiteral(firstArg)) {
-                  msgType = firstArg.getLiteralValue();
-                }
-                // Check if first argument is an object literal: send({ type: "MESSAGE" })
-                else if (Node.isObjectLiteralExpression(firstArg)) {
-                  const typeProperty = firstArg.getProperty("type");
-                  if (typeProperty && Node.isPropertyAssignment(typeProperty)) {
-                    const initializer = typeProperty.getInitializer();
-                    if (initializer && Node.isStringLiteral(initializer)) {
-                      msgType = initializer.getLiteralValue();
-                    }
-                  }
-                }
-
-                if (msgType === messageType) {
-                  senders.push({
-                    context,
-                    file: filePath,
-                    line: node.getStartLineNumber(),
-                  });
-                }
-              }
-            }
-          }
-        }
-      });
-    }
-
-    return senders;
-  }
-
-  /**
-   * Build sequence of steps for a message flow
-   */
-  private buildSequence(
-    messageType: string,
-    sender: { context: string; file: string; line: number },
-    handlers: MessageHandler[]
-  ): MessageStep[] {
-    const steps: MessageStep[] = [];
-    let stepNumber = 1;
-
-    // Step 1: Send message
-    steps.push({
-      step: stepNumber++,
-      action: `${sender.context}.send(${messageType})`,
-      context: sender.context,
-      location: {
-        file: sender.file,
-        line: sender.line,
-      },
-    });
-
-    // Step 2+: Handle in each recipient context
-    for (const handler of handlers) {
-      steps.push({
-        step: stepNumber++,
-        action: `${handler.node}.handle(${messageType})`,
-        context: handler.node,
-        location: handler.location,
-      });
-
-      // Add substeps for any messages sent by this handler
-      const subsends = this.findMessagesInHandler(handler);
-      for (const subsend of subsends) {
-        steps.push({
-          step: stepNumber++,
-          action: `${handler.node}.send(${subsend.messageType})`,
-          context: handler.node,
-          location: subsend.location,
-        });
-      }
-    }
-
-    return steps;
-  }
-
-  /**
-   * Find messages sent within a handler
-   */
-  private findMessagesInHandler(handler: MessageHandler): Array<{
-    messageType: string;
-    location: { file: string; line: number };
-  }> {
-    const sends: Array<{ messageType: string; location: { file: string; line: number } }> = [];
-
-    const sourceFile = this.project.getSourceFile(handler.location.file);
-    if (!sourceFile) return sends;
-
-    // Find the handler function at the given line
-    const targetLine = handler.location.line;
-
-    sourceFile.forEachDescendant((node) => {
-      if (Node.isCallExpression(node)) {
-        const line = node.getStartLineNumber();
-
-        // Rough heuristic: if it's near the handler line, it's probably in the handler
-        if (Math.abs(line - targetLine) < 20) {
-          const expression = node.getExpression();
-
-          if (Node.isPropertyAccessExpression(expression)) {
-            const methodName = expression.getName();
-
-            if (methodName === "send" || methodName === "emit") {
-              const args = node.getArguments();
-              if (args.length > 0) {
-                const firstArg = args[0];
-                let messageType: string | undefined;
-
-                // Check if first argument is a string literal: send("MESSAGE")
-                if (Node.isStringLiteral(firstArg)) {
-                  messageType = firstArg.getLiteralValue();
-                }
-                // Check if first argument is an object literal: send({ type: "MESSAGE" })
-                else if (Node.isObjectLiteralExpression(firstArg)) {
-                  const typeProperty = firstArg.getProperty("type");
-                  if (typeProperty && Node.isPropertyAssignment(typeProperty)) {
-                    const initializer = typeProperty.getInitializer();
-                    if (initializer && Node.isStringLiteral(initializer)) {
-                      messageType = initializer.getLiteralValue();
-                    }
-                  }
-                }
-
-                if (messageType) {
-                  sends.push({
-                    messageType,
-                    location: {
-                      file: handler.location.file,
-                      line,
-                    },
-                  });
-                }
-              }
-            }
-          }
-        }
-      }
-    });
-
-    return sends;
-  }
-
-  /**
-   * Extract flow metadata from JSDoc annotations
-   */
-  private extractFlowMetadata(
-    filePath: string,
-    lineNumber: number
-  ): {
-    trigger?: string;
-    flowName?: string;
-    description?: string;
-  } {
-    const sourceFile = this.project.getSourceFile(filePath);
-    if (!sourceFile) return {};
-
-    // Find the node at this line
-    let targetNode: any = null;
-
-    sourceFile.forEachDescendant((node) => {
-      if (node.getStartLineNumber() === lineNumber) {
-        targetNode = node;
-      }
-    });
-
-    if (!targetNode) return {};
-
-    // Look for JSDoc comments
-    const jsDocs = targetNode.getJsDocs?.() || [];
-    if (jsDocs.length === 0) return {};
-
-    const comment = jsDocs[0].getText();
-
-    // Extract @flow annotation
-    const flowMatch = comment.match(/@flow\s+([^\s]+)/);
-    const flowName = flowMatch ? flowMatch[1] : undefined;
-
-    // Extract @trigger annotation
-    const triggerMatch = comment.match(/@trigger\s+(.+?)(?:\n|$)/);
-    const trigger = triggerMatch ? triggerMatch[1].trim() : undefined;
-
-    // Extract @description
-    const descMatch = comment.match(/@description\s+(.+?)(?:\n|$)/s);
-    const description = descMatch ? descMatch[1].trim() : undefined;
-
-    return { trigger, flowName, description };
-  }
-
-  /**
-   * Infer context from file path
-   */
-  private inferContext(filePath: string): string {
-    const path = filePath.toLowerCase();
-
-    if (path.includes("/background/") || path.includes("\\background\\")) {
-      return "background";
-    }
-    if (path.includes("/content/") || path.includes("\\content\\")) {
-      return "content";
-    }
-    if (path.includes("/popup/") || path.includes("\\popup\\")) {
-      return "popup";
-    }
-    if (path.includes("/devtools/") || path.includes("\\devtools\\")) {
-      return "devtools";
-    }
-    if (path.includes("/options/") || path.includes("\\options\\")) {
-      return "options";
-    }
-    if (path.includes("/offscreen/") || path.includes("\\offscreen\\")) {
-      return "offscreen";
-    }
-
-    return "unknown";
-  }
-}

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

@@ -1,321 +0,0 @@
-// Handler extraction from TypeScript code
-// Extracts message handlers and their state mutations
-
-import { Project, type SourceFile, SyntaxKind, Node } from "ts-morph";
-import type { MessageHandler, StateAssignment, VerificationCondition } from "../types";
-
-export interface HandlerAnalysis {
-  handlers: MessageHandler[];
-  messageTypes: Set<string>;
-}
-
-export class HandlerExtractor {
-  private project: Project;
-
-  constructor(tsConfigPath: string) {
-    this.project = new Project({
-      tsConfigFilePath: tsConfigPath,
-    });
-  }
-
-  /**
-   * Extract all message handlers from the codebase
-   */
-  extractHandlers(): HandlerAnalysis {
-    const handlers: MessageHandler[] = [];
-    const messageTypes = new Set<string>();
-
-    // Find all source files
-    const sourceFiles = this.project.getSourceFiles();
-
-    for (const sourceFile of sourceFiles) {
-      const fileHandlers = this.extractFromFile(sourceFile);
-      handlers.push(...fileHandlers);
-
-      for (const handler of fileHandlers) {
-        messageTypes.add(handler.messageType);
-      }
-    }
-
-    return {
-      handlers,
-      messageTypes,
-    };
-  }
-
-  /**
-   * Extract handlers from a single source file
-   */
-  private extractFromFile(sourceFile: SourceFile): MessageHandler[] {
-    const handlers: MessageHandler[] = [];
-    const filePath = sourceFile.getFilePath();
-
-    // Determine context from file path
-    const context = this.inferContext(filePath);
-
-    // Find all .on() call expressions
-    sourceFile.forEachDescendant((node) => {
-      if (Node.isCallExpression(node)) {
-        const expression = node.getExpression();
-
-        // Check if this is a .on() call
-        if (Node.isPropertyAccessExpression(expression)) {
-          const methodName = expression.getName();
-
-          if (methodName === "on") {
-            const handler = this.extractHandler(node, context, filePath);
-            if (handler) {
-              handlers.push(handler);
-            }
-          }
-        }
-      }
-    });
-
-    return handlers;
-  }
-
-  /**
-   * Extract handler details from a .on() call expression
-   */
-  private extractHandler(callExpr: any, context: string, filePath: string): MessageHandler | null {
-    const args = callExpr.getArguments();
-
-    if (args.length < 2) {
-      return null;
-    }
-
-    // First argument should be the message type (string literal)
-    const messageTypeArg = args[0];
-    let messageType: string | null = null;
-
-    if (Node.isStringLiteral(messageTypeArg)) {
-      messageType = messageTypeArg.getLiteralValue();
-    } else if (Node.isTemplateExpression(messageTypeArg)) {
-      // Handle template literals if needed
-      messageType = messageTypeArg.getText().replace(/[`'"]/g, "");
-    }
-
-    if (!messageType) {
-      return null;
-    }
-
-    // Second argument is the handler function
-    const handlerArg = args[1];
-    const assignments: StateAssignment[] = [];
-    const preconditions: VerificationCondition[] = [];
-    const postconditions: VerificationCondition[] = [];
-
-    // Parse the handler function for state assignments and verification conditions
-    if (Node.isArrowFunction(handlerArg) || Node.isFunctionExpression(handlerArg)) {
-      this.extractAssignments(handlerArg, assignments);
-      this.extractVerificationConditions(handlerArg, preconditions, postconditions);
-    }
-
-    const line = callExpr.getStartLineNumber();
-
-    return {
-      messageType,
-      node: context, // Renamed from 'context' to 'node' for generalization
-      assignments,
-      preconditions,
-      postconditions,
-      location: {
-        file: filePath,
-        line,
-      },
-    };
-  }
-
-  /**
-   * Extract state assignments from a handler function
-   */
-  private extractAssignments(funcNode: any, assignments: StateAssignment[]): void {
-    funcNode.forEachDescendant((node: any) => {
-      // Look for assignment expressions: state.field = value
-      if (Node.isBinaryExpression(node)) {
-        const operator = node.getOperatorToken().getText();
-
-        if (operator === "=") {
-          const left = node.getLeft();
-          const right = node.getRight();
-
-          // Check if left side is a state property access
-          if (Node.isPropertyAccessExpression(left)) {
-            const fieldPath = this.getPropertyPath(left);
-
-            // Check if this is a state access
-            if (fieldPath.startsWith("state.")) {
-              const field = fieldPath.substring(6); // Remove "state." prefix
-              const value = this.extractValue(right);
-
-              if (value !== undefined) {
-                assignments.push({
-                  field,
-                  value,
-                });
-              }
-            }
-          }
-        }
-      }
-    });
-  }
-
-  /**
-   * Extract verification conditions (requires/ensures) from a handler function
-   */
-  private extractVerificationConditions(
-    funcNode: any,
-    preconditions: VerificationCondition[],
-    postconditions: VerificationCondition[]
-  ): void {
-    const body = funcNode.getBody();
-
-    // Get all statements in the function body
-    const statements = Node.isBlock(body) ? body.getStatements() : [body];
-
-    statements.forEach((statement: any, index: number) => {
-      // Look for expression statements that are function calls
-      if (Node.isExpressionStatement(statement)) {
-        const expr = statement.getExpression();
-
-        if (Node.isCallExpression(expr)) {
-          const callee = expr.getExpression();
-
-          if (Node.isIdentifier(callee)) {
-            const functionName = callee.getText();
-
-            if (functionName === "requires") {
-              // Extract precondition
-              const condition = this.extractCondition(expr);
-              if (condition) {
-                preconditions.push(condition);
-              }
-            } else if (functionName === "ensures") {
-              // Extract postcondition
-              const condition = this.extractCondition(expr);
-              if (condition) {
-                postconditions.push(condition);
-              }
-            }
-          }
-        }
-      }
-    });
-  }
-
-  /**
-   * Extract condition from a requires() or ensures() call
-   */
-  private extractCondition(callExpr: any): VerificationCondition | null {
-    const args = callExpr.getArguments();
-
-    if (args.length === 0) {
-      return null;
-    }
-
-    // First argument is the condition expression
-    const conditionArg = args[0];
-    const expression = conditionArg.getText();
-
-    // Second argument (optional) is the message
-    let message: string | undefined;
-    if (args.length >= 2 && Node.isStringLiteral(args[1])) {
-      message = args[1].getLiteralValue();
-    }
-
-    const line = callExpr.getStartLineNumber();
-    const column = callExpr.getStartLinePos();
-
-    return {
-      expression,
-      message,
-      location: {
-        line,
-        column,
-      },
-    };
-  }
-
-  /**
-   * Get the full property access path (e.g., "state.user.loggedIn")
-   */
-  private getPropertyPath(node: any): string {
-    const parts: string[] = [];
-
-    let current = node;
-    while (Node.isPropertyAccessExpression(current)) {
-      parts.unshift(current.getName());
-      current = current.getExpression();
-    }
-
-    // Add the base identifier
-    if (Node.isIdentifier(current)) {
-      parts.unshift(current.getText());
-    }
-
-    return parts.join(".");
-  }
-
-  /**
-   * Extract a literal value from an expression
-   */
-  private extractValue(node: any): string | boolean | number | null | undefined {
-    if (Node.isStringLiteral(node)) {
-      return node.getLiteralValue();
-    }
-
-    if (Node.isNumericLiteral(node)) {
-      return node.getLiteralValue();
-    }
-
-    if (node.getKind() === SyntaxKind.TrueKeyword) {
-      return true;
-    }
-
-    if (node.getKind() === SyntaxKind.FalseKeyword) {
-      return false;
-    }
-
-    if (node.getKind() === SyntaxKind.NullKeyword) {
-      return null;
-    }
-
-    // For complex expressions, return undefined (can't extract)
-    return undefined;
-  }
-
-  /**
-   * Infer the context (background, content, popup, etc.) from file path
-   */
-  private inferContext(filePath: string): string {
-    const path = filePath.toLowerCase();
-
-    if (path.includes("/background/") || path.includes("\\background\\")) {
-      return "background";
-    }
-    if (path.includes("/content/") || path.includes("\\content\\")) {
-      return "content";
-    }
-    if (path.includes("/popup/") || path.includes("\\popup\\")) {
-      return "popup";
-    }
-    if (path.includes("/devtools/") || path.includes("\\devtools\\")) {
-      return "devtools";
-    }
-    if (path.includes("/options/") || path.includes("\\options\\")) {
-      return "options";
-    }
-    if (path.includes("/offscreen/") || path.includes("\\offscreen\\")) {
-      return "offscreen";
-    }
-
-    return "unknown";
-  }
-}
-
-export function extractHandlers(tsConfigPath: string): HandlerAnalysis {
-  const extractor = new HandlerExtractor(tsConfigPath);
-  return extractor.extractHandlers();
-}

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

@@ -1,9 +0,0 @@
-// Export all extraction utilities
-export * from "./types";
-export * from "./handlers";
-export * from "./manifest";
-export * from "./contexts";
-export * from "./flows";
-export * from "./integrations";
-export * from "./adr";
-export * from "./architecture";