@mnemonica/tactica 0.1.0 → 0.1.2

package/lib/analyzer.d.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { AnalyzeResult } from './types';
+import { AnalyzeResult, DefinitionInfo, UsageInfo, EDSInfo, FlowInfo } from './types';
 import { TypeGraphImpl } from './graph';
 /**
  * AST Analyzer for finding Mnemonica define() and decorate() calls
@@ -7,7 +7,18 @@ import { TypeGraphImpl } from './graph';
 export declare class MnemonicaAnalyzer {
     private errors;
     private graph;
+    private definitions;
+    private usages;
+    private edsUsages;
+    private flowUsages;
+    private typeAliases;
+    private variableToTypeMap;
     constructor(program?: ts.Program);
+    /**
+     * Reset usage-related state for a fresh pass.
+     * Call before the usage-collection pass to avoid duplicates from definition pass.
+     */
+    resetUsages(): void;
     /**
      * Analyze a source file for Mnemonica type definitions
      */
@@ -20,6 +31,31 @@ export declare class MnemonicaAnalyzer {
      * Get the type graph
      */
     getGraph(): TypeGraphImpl;
+    /**
+     * Get collected definitions
+     */
+    getDefinitions(): Map<string, DefinitionInfo>;
+    /**
+     * Get collected usages
+     */
+    getUsages(): Map<string, UsageInfo[]>;
+    /**
+     * Get collected EDS usages
+     */
+    getEDSUsages(): Map<string, EDSInfo[]>;
+    /**
+     * Get collected flow usages
+     */
+    getFlowUsages(): Map<string, FlowInfo[]>;
+    /**
+     * Add a topologica type to the analyzer for usage tracking.
+     * This allows the analyzer to recognize topologica types when collecting usages.
+     */
+    addTopologicaType(fullPath: string, node: import('./types').TypeNode): void;
+    /**
+     * Set parent nodes in a source file to enable AST traversal up
+     */
+    private setParentNodesInSourceFile;
     /**
      * Visit a node in the AST
      */
@@ -29,15 +65,35 @@ export declare class MnemonicaAnalyzer {
      */
     private isDefineCall;
     /**
-     * Check if a node is a @decorate() decorator
-     */
+        * Extract config options from define() call
+        */
+    private extractConfig;
+    /**
+        * Check if a node is a @decorate() decorator
+        */
     private isDecorateDecorator;
     /**
      * Process a define() call
      */
     private processDefineCall;
     /**
-     * Process a @decorate() decorator
+        * Track variable assignments that capture define() results
+        * e.g., const User = define('UserEntity', ...) maps "User" -> "UserEntity"
+        * For chained calls like const X = define('A').define('B'), we map X -> A (the root type)
+        */
+    private trackVariableAssignment;
+    /**
+        * Track variable assignments from lookup() calls
+        * e.g., const SentienceConstructor = lookup('Sentience') maps "SentienceConstructor" -> "Sentience"
+        */
+    private trackLookupAssignment;
+    /**
+        * Track variable assignments from new Type() calls
+        * e.g., const user = new UserType() maps "user" -> "UserType"
+        */
+    private trackNewAssignment;
+    /**
+        * Process a @decorate() decorator
      */
     private processDecorateDecorator;
     /**
@@ -49,27 +105,159 @@ export declare class MnemonicaAnalyzer {
      */
     private findParentType;
     /**
-     * Get property chain from nested access
-     */
+        * Find a parent type by its name, searching in the graph
+        */
+    private findParentTypeByName;
+    /**
+        * Get property chain from nested access
+        */
     private getPropertyChain;
     /**
      * Extract properties from constructor function
      */
     private extractProperties;
+    /**
+     * Build a type map from all parameters with inline object type annotations
+     * Returns a map of "paramName.propertyName" -> type
+     */
+    private buildDataTypeMap;
+    /**
+     * Extract property access chain (e.g., "dataRenamed.id" from dataRenamed.id)
+     * Handles fallbacks like: data.permissions || []
+     */
+    private getPropertyAccessChain;
     /**
      * Extract property assignment from statement
      */
     private extractPropertyFromStatement;
     /**
-     * Extract properties from class declaration
+     * Extract properties from class declaration (including methods and getters)
      */
     private extractClassProperties;
+    /**
+     * Extract class property types for method return type inference
+     * Maps property names to their TypeScript type strings
+     * Note: Includes private/protected properties for method inference
+     */
+    private extractClassPropertyTypes;
+    /**
+     * Infer method type from method declaration
+     */
+    private inferMethodType;
+    /**
+        * Extract properties from `this` parameter type annotation
+        * Handles patterns like: function(this: SomeType, data: SomeType) { }
+        */
+    private extractThisParamProperties;
+    /**
+        * Infer TypeScript type from type node
+        */
     /**
      * Infer TypeScript type from type node
      */
     private inferType;
+    /**
+        * Infer return type from a method declaration
+        * Uses explicit return type annotation or infers from return statements
+        */
+    private inferReturnType;
+    /**
+        * Infer return type by analyzing return statements in the method body
+        */
+    private inferReturnTypeFromBody;
+    /**
+        * Get full text from a qualified name (e.g., Namespace.Type)
+        */
+    private getQualifiedNameText;
     /**
      * Infer type from initializer
      */
     private inferTypeFromInitializer;
+    /**
+        * Collect usage information for type references
+        */
+    private collectUsage;
+    /**
+        * Get function name from expression (identifier or property access)
+        */
+    private getFunctionName;
+    /**
+        * Add a usage to the collection
+        */
+    private addUsage;
+    /**
+     * Collect EDS (Execution Data Storage) usage information
+     */
+    private collectEDS;
+    /**
+     * Resolve type from EDS call argument (best effort)
+     */
+    private resolveEDSArgumentType;
+    /**
+     * Add an EDS usage to the collection
+     */
+    private addEDS;
+    /**
+     * Collect native flow patterns (instance usage after creation)
+     * Phase 1: property access, method calls, arguments, return, destructuring, etc.
+     */
+    private collectFlow;
+    /**
+     * Collect property access flow (read or conditional)
+     */
+    private collectFlowPropertyAccess;
+    /**
+     * Collect element access flow: user['name']
+     */
+    private collectFlowElementAccess;
+    /**
+     * Collect assignment flow: user.name = value or user = other
+     */
+    private collectFlowAssignment;
+    /**
+     * Collect method call flow: user.validate()
+     */
+    private collectFlowMethodCall;
+    /**
+     * Collect argument passing flow: processUser(user)
+     */
+    private collectFlowArgumentPass;
+    /**
+     * Collect destructuring flow: const { name } = user
+     */
+    private collectFlowDestructure;
+    /**
+     * Collect return flow: return user
+     */
+    private collectFlowReturn;
+    /**
+     * Collect spread flow: { ...user }
+     */
+    private collectFlowSpread;
+    /**
+     * Resolve type from an expression (identifier, property access, etc.)
+     */
+    private resolveExpressionType;
+    /**
+     * Add a flow usage to the collection
+     */
+    private addFlow;
+    /**
+            * Get type name from expression (identifier or property access)
+            */
+    private getTypeNameFromExpression;
+    /**
+        * Resolve full type path from property access
+        */
+    private resolveTypePath;
+    /**
+         * Check if a name looks like a type (starts with uppercase)
+         */
+    private isLikelyTypeName;
+    /**
+         * Extract constructor parameters from define() call
+         * This is used for TypeRegistry constructor signatures
+         * Preserves parameter names and expands object types to their structure
+         */
+    private extractConstructorParams;
 }