@grafema/core 0.1.0-alpha.1

package/src/plugins/analysis/ast/OxcAdapter.ts

@@ -0,0 +1,63 @@
+/**
+ * OxcAdapter - адаптер для перехода с Babel на Oxc parser
+ * Предоставляет API совместимый с Babel parse и traverse
+ */
+
+import { parseSync, Visitor } from 'oxc-parser';
+import type * as t from '@babel/types';
+
+/**
+ * Parse options
+ */
+interface ParseOptions {
+  filename?: string;
+  sourceType?: 'module' | 'script';
+  plugins?: string[];
+}
+
+/**
+ * Visitor handlers type
+ */
+interface VisitorHandlers {
+  [key: string]: ((node: t.Node) => void) | undefined;
+}
+
+/**
+ * Parse code with Oxc (compatible with Babel parse API)
+ * @param code - Source code to parse
+ * @param options - Parse options
+ * @returns AST with program property
+ */
+export function parse(code: string, options: ParseOptions = {}): t.Program {
+  // Oxc doesn't need sourceType or plugins config
+  // It auto-detects JSX and handles all modern syntax
+  const filename = options.filename || 'unknown.js';
+
+  const result = parseSync(filename, code);
+
+  // Oxc returns { program, comments, errors }
+  // Babel returns just the program node
+  // For compatibility, return the program directly
+  return result.program as unknown as t.Program;
+}
+
+/**
+ * Traverse AST with Oxc Visitor (compatible with Babel traverse API)
+ * @param ast - AST to traverse
+ * @param visitors - Visitor handlers
+ */
+export function traverse(ast: t.Node, visitors: VisitorHandlers): void {
+  // Oxc Visitor accepts an object with node type handlers
+  // This is already compatible with our Babel usage pattern
+  const visitor = new Visitor(visitors as unknown as Record<string, (node: unknown) => void>);
+  // Cast to Oxc Program through unknown - types are structurally similar but from different packages
+  visitor.visit(ast as unknown as Parameters<typeof visitor.visit>[0]);
+}
+
+/**
+ * Default export for compatibility
+ */
+export default {
+  parse,
+  traverse
+};

package/src/plugins/analysis/ast/types.ts

@@ -0,0 +1,400 @@
+/**
+ * AST Analysis Types - общие типы для JSASTAnalyzer и GraphBuilder
+ */
+
+import type * as t from '@babel/types';
+import type { GraphBackend } from '@grafema/types';
+
+// === MODULE NODE ===
+export interface ModuleNode {
+  id: string;
+  type: 'MODULE';
+  name: string;
+  file: string;
+  line: number;
+  contentHash?: string;
+  [key: string]: unknown;
+}
+
+// === FUNCTION INFO ===
+export interface FunctionInfo {
+  id: string;
+  stableId: string;
+  type: 'FUNCTION';
+  name: string;
+  file: string;
+  line: number;
+  column: number;
+  async?: boolean;
+  generator?: boolean;
+  arrowFunction?: boolean;
+  isAssignment?: boolean;
+  isCallback?: boolean;
+  parentScopeId?: string;
+}
+
+// === PARAMETER INFO ===
+export interface ParameterInfo {
+  id: string;
+  type: 'PARAMETER';
+  name: string;
+  file: string;
+  line: number;
+  index?: number;
+  functionId: string;
+  parentFunctionId?: string;
+}
+
+// === SCOPE INFO ===
+export interface ScopeInfo {
+  id: string;
+  type: 'SCOPE';
+  scopeType: string;
+  name?: string;
+  semanticId?: string;  // Stable ID for diff comparison (e.g., "MyClass.myMethod:if_statement[0]")
+  conditional?: boolean;
+  condition?: string;
+  constraints?: unknown[];
+  file?: string;
+  line: number;
+  parentScopeId?: string;
+  parentFunctionId?: string;
+  capturesFrom?: string;
+  modifies?: Array<{ variableId: string; variableName: string; line: number }>;
+}
+
+// === VARIABLE DECLARATION INFO ===
+export interface VariableDeclarationInfo {
+  id: string;
+  type: 'VARIABLE' | 'CONSTANT';
+  name: string;
+  file: string;
+  line: number;
+  column?: number;
+  value?: unknown;
+  parentScopeId?: string;
+}
+
+// === CALL SITE INFO ===
+export interface CallSiteInfo {
+  id: string;
+  type: 'CALL';
+  name: string;
+  file: string;
+  line: number;
+  column?: number;
+  parentScopeId?: string;
+  targetFunctionName?: string;
+  isNew?: boolean;
+}
+
+// === METHOD CALL INFO ===
+export interface MethodCallInfo {
+  id: string;
+  type: 'CALL';
+  name: string;
+  object: string;
+  method: string;
+  file: string;
+  line: number;
+  column?: number;
+  parentScopeId?: string;
+  arguments?: unknown[];
+  isNew?: boolean;
+}
+
+// === EVENT LISTENER INFO ===
+export interface EventListenerInfo {
+  id: string;
+  type: 'event:listener';
+  name: string;
+  object: string;
+  file: string;
+  line: number;
+  parentScopeId?: string;
+  callbackArg?: t.Node;
+}
+
+// === CLASS INSTANTIATION INFO ===
+export interface ClassInstantiationInfo {
+  variableId: string;
+  variableName: string;
+  className: string;
+  line: number;
+  parentScopeId?: string;
+}
+
+// === CLASS DECLARATION INFO ===
+export interface ClassDeclarationInfo {
+  id: string;
+  type: 'CLASS';
+  name: string;
+  file: string;
+  line: number;
+  column?: number;
+  superClass?: string;
+  implements?: string[];  // имена интерфейсов, которые реализует класс
+  methods: string[];
+}
+
+// === INTERFACE DECLARATION INFO ===
+export interface InterfaceDeclarationInfo {
+  id: string;
+  type: 'INTERFACE';
+  name: string;
+  file: string;
+  line: number;
+  column?: number;
+  extends?: string[];  // имена родительских интерфейсов
+  properties: InterfacePropertyInfo[];
+}
+
+export interface InterfacePropertyInfo {
+  name: string;
+  type?: string;
+  optional?: boolean;
+  readonly?: boolean;
+}
+
+// === TYPE ALIAS INFO ===
+export interface TypeAliasInfo {
+  id: string;
+  type: 'TYPE';
+  name: string;
+  file: string;
+  line: number;
+  column?: number;
+  aliasOf?: string;  // строковое представление типа
+}
+
+// === ENUM DECLARATION INFO ===
+export interface EnumDeclarationInfo {
+  id: string;
+  type: 'ENUM';
+  name: string;
+  file: string;
+  line: number;
+  column?: number;
+  isConst?: boolean;  // const enum
+  members: EnumMemberInfo[];
+}
+
+export interface EnumMemberInfo {
+  name: string;
+  value?: string | number;
+}
+
+// === DECORATOR INFO ===
+export interface DecoratorInfo {
+  id: string;
+  type: 'DECORATOR';
+  name: string;
+  file: string;
+  line: number;
+  column?: number;
+  arguments?: unknown[];  // аргументы декоратора
+  targetId: string;       // ID класса/метода/свойства
+  targetType: 'CLASS' | 'METHOD' | 'PROPERTY' | 'PARAMETER';
+}
+
+// === METHOD CALLBACK INFO ===
+export interface MethodCallbackInfo {
+  methodCallId: string;
+  callbackLine: number;
+  callbackColumn: number;
+  callbackType: string;
+}
+
+// === CALL ARGUMENT INFO ===
+export interface CallArgumentInfo {
+  callId: string;
+  argIndex: number;
+  argValue?: unknown;
+  targetType?: string;
+  targetId?: string;
+  targetName?: string;
+  file?: string;
+  isSpread?: boolean;
+  functionLine?: number;
+  functionColumn?: number;
+  nestedCallLine?: number;
+  nestedCallColumn?: number;
+}
+
+// === IMPORT INFO ===
+export interface ImportInfo {
+  id: string;
+  type: 'IMPORT';
+  name: string;
+  source: string;
+  file: string;
+  line: number;
+  specifiers: ImportSpecifier[];
+}
+
+export interface ImportSpecifier {
+  imported: string;  // имя в экспортируемом модуле (default, *, или имя)
+  local: string;     // имя в текущем модуле
+}
+
+// === EXPORT INFO ===
+export interface ExportInfo {
+  id: string;
+  type: 'EXPORT' | 'default' | 'named' | 'all';
+  name: string;
+  file: string;
+  line: number;
+  specifiers?: ExportSpecifier[];
+  source?: string;  // для re-exports: export { foo } from './other'
+}
+
+export interface ExportSpecifier {
+  local: string;
+  exported: string;
+}
+
+// === HTTP REQUEST INFO ===
+export interface HttpRequestInfo {
+  id: string;
+  type: 'http:request';
+  method: string;
+  url: string;
+  file: string;
+  line: number;
+  parentScopeId?: string;
+}
+
+// === LITERAL INFO ===
+export interface LiteralInfo {
+  id: string;
+  type: 'LITERAL' | 'CALL';
+  value?: unknown;
+  valueType?: string;
+  name?: string;
+  object?: string;
+  method?: string;
+  arguments?: unknown[];
+  file: string;
+  line: number;
+  column?: number;
+  parentCallId?: string;
+  argIndex?: number;
+}
+
+// === VARIABLE ASSIGNMENT INFO ===
+export interface VariableAssignmentInfo {
+  variableId: string;
+  sourceId?: string | null;
+  sourceType: string;
+  callName?: string;
+  callLine?: number;
+  callColumn?: number;
+  sourceName?: string;
+  sourceLine?: number;
+  sourceColumn?: number;
+  sourceFile?: string;
+  className?: string;
+  functionName?: string;
+  line?: number;
+  expressionType?: string;
+  object?: string;
+  property?: string;
+  computed?: boolean;
+  computedPropertyVar?: string | null;
+  objectSourceName?: string | null;
+  operator?: string;
+  leftSourceName?: string | null;
+  rightSourceName?: string | null;
+  consequentSourceName?: string | null;
+  alternateSourceName?: string | null;
+  expressionSourceNames?: string[];
+  file?: string;
+}
+
+// === COUNTER REF ===
+export interface CounterRef {
+  value: number;
+}
+
+// === PROCESSED NODES ===
+export interface ProcessedNodes {
+  functions: Set<string>;
+  classes: Set<string>;
+  imports: Set<string>;
+  exports: Set<string>;
+  variables: Set<string>;
+  callSites: Set<string>;
+  methodCalls: Set<string>;
+  varDecls: Set<string>;
+  eventListeners: Set<string>;
+  [key: string]: Set<string>;
+}
+
+// === COLLECTIONS (все данные для GraphBuilder) ===
+export interface ASTCollections {
+  functions: FunctionInfo[];
+  parameters?: ParameterInfo[];
+  scopes: ScopeInfo[];
+  variableDeclarations: VariableDeclarationInfo[];
+  callSites: CallSiteInfo[];
+  methodCalls?: MethodCallInfo[];
+  eventListeners?: EventListenerInfo[];
+  classInstantiations?: ClassInstantiationInfo[];
+  classDeclarations?: ClassDeclarationInfo[];
+  methodCallbacks?: MethodCallbackInfo[];
+  callArguments?: CallArgumentInfo[];
+  imports?: ImportInfo[];
+  exports?: ExportInfo[];
+  httpRequests?: HttpRequestInfo[];
+  literals?: LiteralInfo[];
+  variableAssignments?: VariableAssignmentInfo[];
+  // TypeScript-specific collections
+  interfaces?: InterfaceDeclarationInfo[];
+  typeAliases?: TypeAliasInfo[];
+  enums?: EnumDeclarationInfo[];
+  decorators?: DecoratorInfo[];
+  // Counter refs (used internally during collection)
+  ifScopeCounterRef?: CounterRef;
+  scopeCounterRef?: CounterRef;
+  varDeclCounterRef?: CounterRef;
+  callSiteCounterRef?: CounterRef;
+  functionCounterRef?: CounterRef;
+  httpRequestCounterRef?: CounterRef;
+  literalCounterRef?: CounterRef;
+  processedNodes?: ProcessedNodes;
+}
+
+// === EXTRACTED VARIABLE ===
+export interface ExtractedVariable {
+  name: string;
+  loc: { start: { line: number; column: number } };
+  propertyPath?: string[];
+  arrayIndex?: number;
+  isRest?: boolean;
+}
+
+// === GRAPH NODE (generic node for buffer) ===
+export interface GraphNode {
+  id: string;
+  type: string;
+  name?: string;
+  file?: string;
+  line?: number;
+  column?: number;
+  [key: string]: unknown;
+}
+
+// === GRAPH EDGE (generic edge for buffer) ===
+export interface GraphEdge {
+  type: string;
+  src: string;
+  dst: string;
+  index?: number;
+  metadata?: Record<string, unknown>;
+}
+
+// === BUILD RESULT ===
+export interface BuildResult {
+  nodes: number;
+  edges: number;
+}

package/src/plugins/analysis/ast/visitors/ASTVisitor.ts

@@ -0,0 +1,137 @@
+/**
+ * Base class for AST visitors
+ * Each visitor handles specific AST node types and collects relevant data
+ */
+import type { Node, SourceLocation } from '@babel/types';
+import type { NodePath } from '@babel/traverse';
+import type {
+  FunctionInfo,
+  ClassDeclarationInfo,
+  ClassInstantiationInfo,
+  ScopeInfo,
+  VariableDeclarationInfo,
+  CallSiteInfo,
+  MethodCallInfo,
+  EventListenerInfo,
+  MethodCallbackInfo,
+  LiteralInfo,
+  ImportInfo,
+  ExportInfo,
+  HttpRequestInfo,
+  VariableAssignmentInfo,
+  CallArgumentInfo,
+  ParameterInfo,
+  CounterRef,
+  ProcessedNodes
+} from '../types.js';
+
+/**
+ * Module info passed to visitors
+ */
+export interface VisitorModule {
+  id: string;
+  file: string;
+  name: string;
+  [key: string]: unknown;
+}
+
+// Re-export types that were previously defined locally
+export type { CounterRef, ProcessedNodes, VariableAssignmentInfo as VariableAssignment };
+
+/**
+ * Shared collections populated by visitors
+ */
+export interface VisitorCollections {
+  // Core collections - all optional for partial passing
+  functions?: FunctionInfo[];
+  classes?: ClassDeclarationInfo[];
+  methods?: FunctionInfo[];  // Methods are also FunctionInfo
+  imports?: ImportInfo[];
+  exports?: ExportInfo[];
+  variables?: VariableDeclarationInfo[];
+  variableDeclarations?: VariableDeclarationInfo[];  // Alias for variables
+  variableAssignments?: VariableAssignmentInfo[];
+  callSites?: CallSiteInfo[];
+  methodCalls?: MethodCallInfo[];
+  eventListeners?: EventListenerInfo[];
+  methodCallbacks?: MethodCallbackInfo[];
+  classInstantiations?: ClassInstantiationInfo[];
+  classDeclarations?: ClassDeclarationInfo[];  // Alias for classes
+  literals?: LiteralInfo[];
+  callArguments?: CallArgumentInfo[];
+  scopes?: ScopeInfo[];
+  httpRequests?: HttpRequestInfo[];
+  parameters?: ParameterInfo[];
+  sideEffects?: unknown[];  // TODO: define SideEffectInfo type
+  code?: string;  // Source code for condition extraction
+
+  // Counters - optional
+  functionCounterRef?: CounterRef;
+  callSiteCounterRef?: CounterRef;
+  literalCounterRef?: CounterRef;
+  variableCounterRef?: CounterRef;
+  scopeCounterRef?: CounterRef;
+  ifScopeCounterRef?: CounterRef;
+  varDeclCounterRef?: CounterRef;
+  httpRequestCounterRef?: CounterRef;
+  anonymousFunctionCounterRef?: CounterRef;
+
+  // Deduplication - optional
+  processedNodes?: ProcessedNodes;
+
+  // Allow additional collections
+  [key: string]: unknown;
+}
+
+/**
+ * Location info extracted from AST node
+ */
+export interface LocationInfo {
+  line: number | undefined;
+  column: number | undefined;
+}
+
+/**
+ * Handler function type for Babel traverse
+ */
+export type VisitorHandler = (path: NodePath) => void;
+
+/**
+ * Visitor handlers object
+ */
+export interface VisitorHandlers {
+  [nodeType: string]: VisitorHandler;
+}
+
+/**
+ * Base class for AST visitors
+ */
+export abstract class ASTVisitor {
+  protected module: VisitorModule;
+  protected collections: VisitorCollections;
+
+  /**
+   * @param module - Current module being analyzed (file, path etc)
+   * @param collections - Shared collections to populate
+   */
+  constructor(module: VisitorModule, collections: VisitorCollections) {
+    this.module = module;
+    this.collections = collections;
+  }
+
+  /**
+   * Returns the Babel traverse visitor handlers
+   * @returns Object with AST node type handlers
+   */
+  abstract getHandlers(): VisitorHandlers;
+
+  /**
+   * Utility to get source location info
+   */
+  protected getLoc(node: Node): LocationInfo {
+    return {
+      line: node.loc?.start?.line,
+      column: node.loc?.start?.column
+    };
+  }
+}