fix: modify Package mapping logic (#103)

* fix bug: cannot identify export default arrow function

* fix bug: if two files has same symbol name, should give a mangled name

* 1. revert import path changes 2. fix bug: falsy caching strategy in  function,

* chore: modify package version

* modify Package mapping logic

* build symbol cache based on file, not on its directory

Author: angrychow

ts-parser/package.json

@@ -1,7 +1,7 @@
 {
   "name": "abcoder-ts-parser",
-  "version": "0.0.8",
-  "description": "TypeScript AST parser for UNIAST v0.1.3 specification",
+  "version": "0.0.9",
+  "description": "TypeScript AST parser for UNIAST specification",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {

ts-parser/src/index.ts

@@ -9,8 +9,8 @@ const program = new Command();
 
 program
   .name('abcoder-ts-parser')
-  .description('TypeScript AST parser for UNIAST v0.1.3 specification')
-  .version('0.0.4');
+  .description('TypeScript AST parser for UNIAST specification')
+  .version('0.0.9');
 
 program
   .command('parse')

ts-parser/src/parser/RepositoryParser.ts

@@ -153,8 +153,10 @@ export class RepositoryParser {
   private async processPackagesWithClusterMode(
     packages: MonorepoPackage[],
     repository: Repository,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     options: any
   ): Promise<void> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     if ((cluster as any).isPrimary || (cluster as any).isMaster) {
       const result = await processPackagesWithCluster(packages, this.projectRoot, options);
 

ts-parser/src/parser/test/FunctionParser.test.ts

@@ -317,23 +317,70 @@ describe('FunctionParser', () => {
           second() { return this; }
           third() { return 'done'; }
         }
-        
+
         function chainUser() {
           new Chain().first().second().third();
         }
       `);
-      
+
       const parser = new FunctionParser(project, process.cwd());
       let pkgPathAbsFile : string = sourceFile.getFilePath()
       pkgPathAbsFile = pkgPathAbsFile.split('/').slice(0, -1).join('/')
       const pkgPath = path.relative(process.cwd(), pkgPathAbsFile)
-      
-      
+
+
       const functions = parser.parseFunctions(sourceFile, 'parser-tests', pkgPath);
-      
+
       const chainUser = expectToBeDefined(functions['chainUser']);
       expect(chainUser.MethodCalls).toBeDefined();
-      
+
+      cleanup();
+    });
+
+    it('should extract method calls on parameter objects', () => {
+      const { project, sourceFile, cleanup } = createTestProject(`
+        interface Context {
+          logError(message: string, error: any): void;
+          render(template: string, data: any): Promise<void>;
+          status: number;
+        }
+
+        function getConfig(key: string, ctx: any): Promise<any> {
+          return Promise.resolve({ value: 'default' });
+        }
+
+        async function handleRequest(ctx: Context, error: any) {
+          if (error.code === 404) {
+            ctx.status = 404;
+            return;
+          }
+          ctx.logError('Error occurred: ' + error.message, error);
+          const config = await getConfig('app.config', ctx);
+          await ctx.render('error-page', { message: config.value || error.message || '' });
+          ctx.status = 500;
+        }
+      `);
+
+      const parser = new FunctionParser(project, process.cwd());
+      let pkgPathAbsFile : string = sourceFile.getFilePath()
+      pkgPathAbsFile = pkgPathAbsFile.split('/').slice(0, -1).join('/')
+      const pkgPath = path.relative(process.cwd(), pkgPathAbsFile)
+
+      const functions = parser.parseFunctions(sourceFile, 'parser-tests', pkgPath);
+
+      const handleRequest = expectToBeDefined(functions['handleRequest']);
+      expect(handleRequest.MethodCalls).toBeDefined();
+
+      const methodCallNames = expectToBeDefined(handleRequest.MethodCalls).map(call => call.Name);
+      // Method calls on parameter objects should include the interface name prefix
+      expect(methodCallNames).toContain('Context.logError');
+      expect(methodCallNames).toContain('Context.render');
+
+      // Should also have function calls
+      expect(handleRequest.FunctionCalls).toBeDefined();
+      const functionCallNames = expectToBeDefined(handleRequest.FunctionCalls).map(call => call.Name);
+      expect(functionCallNames).toContain('getConfig');
+
       cleanup();
     });
   });

ts-parser/src/parser/test/RepositoryParser.test.ts

@@ -248,31 +248,42 @@ export interface ServerConfig {
       const sharedUtilsModule = result.Modules['@test/shared-utils'];
       expect(sharedUtilsModule).toBeDefined();
       expect(sharedUtilsModule.Packages).toBeDefined();
-      expect(sharedUtilsModule.Packages.src).toBeDefined();
+
+      // Collect all functions, types, and vars from all file-based packages
+      const allFunctions: Record<string, any> = {};
+      const allTypes: Record<string, any> = {};
+      const allVars: Record<string, any> = {};
+
+      Object.values(sharedUtilsModule.Packages).forEach((pkg: any) => {
+        if (pkg.Functions) Object.assign(allFunctions, pkg.Functions);
+        if (pkg.Types) Object.assign(allTypes, pkg.Types);
+        if (pkg.Vars) Object.assign(allVars, pkg.Vars);
+      });
 
       // Verify functions are parsed
-      const sharedUtilsFunctions = sharedUtilsModule.Packages.src.Functions;
-      expect(sharedUtilsFunctions).toBeDefined();
-      expect(sharedUtilsFunctions['formatMessage']).toBeDefined();
-      expect(sharedUtilsFunctions['capitalize']).toBeDefined();
-      expect(sharedUtilsFunctions['formatDate']).toBeDefined();
-      expect(sharedUtilsFunctions['addDays']).toBeDefined();
+      expect(allFunctions['formatMessage']).toBeDefined();
+      expect(allFunctions['capitalize']).toBeDefined();
+      expect(allFunctions['formatDate']).toBeDefined();
+      expect(allFunctions['addDays']).toBeDefined();
 
       // Verify types are parsed
-      const sharedUtilsTypes = sharedUtilsModule.Packages.src.Types;
-      expect(sharedUtilsTypes).toBeDefined();
-      expect(sharedUtilsTypes['StringOptions']).toBeDefined();
+      expect(allTypes['StringOptions']).toBeDefined();
 
       // Verify variables are parsed
-      const sharedUtilsVars = sharedUtilsModule.Packages.src.Vars;
-      expect(sharedUtilsVars).toBeDefined();
-      expect(sharedUtilsVars['SHARED_CONSTANTS']).toBeDefined();
+      expect(allVars['SHARED_CONSTANTS']).toBeDefined();
 
       // Verify api-server module
       const apiServerModule = result.Modules['@test/api-server'];
       expect(apiServerModule).toBeDefined();
-      expect(apiServerModule.Packages.src.Types['ApiServer']).toBeDefined();
-      expect(apiServerModule.Packages.src.Types['ServerConfig']).toBeDefined();
+
+      // Collect types from api-server packages
+      const apiServerTypes: Record<string, any> = {};
+      Object.values(apiServerModule.Packages).forEach((pkg: any) => {
+        if (pkg.Types) Object.assign(apiServerTypes, pkg.Types);
+      });
+
+      expect(apiServerTypes['ApiServer']).toBeDefined();
+      expect(apiServerTypes['ServerConfig']).toBeDefined();
 
       // Verify dependency graph includes cross-package dependencies
       expect(result.Graph).toBeDefined();
@@ -476,7 +487,14 @@ export class WebApplication {
 
       // Verify inheritance is captured
       const uiModule = result.Modules['@test/ui-components'];
-      const uiServiceType = uiModule.Packages.src.Types['UIService'];
+
+      // Collect types from all ui-components packages
+      const uiTypes: Record<string, any> = {};
+      Object.values(uiModule.Packages).forEach((pkg: any) => {
+        if (pkg.Types) Object.assign(uiTypes, pkg.Types);
+      });
+
+      const uiServiceType = uiTypes['UIService'];
       expect(uiServiceType).toBeDefined();
       expect(uiServiceType.Exported).toBe(true);
 
@@ -668,18 +686,34 @@ export function createButton(props: ComponentProps): string {
       // Verify core module structure
       const coreModule = result.Modules['@test/core'];
       expect(coreModule).toBeDefined();
-      expect(coreModule.Packages.src).toBeDefined();
-      expect(coreModule.Packages.src.Types['Config']).toBeDefined();
-      expect(coreModule.Packages.src.Types['BaseService']).toBeDefined();
-      expect(coreModule.Packages.src.Functions['createConfig']).toBeDefined();
+
+      // Collect types and functions from all core packages
+      const coreTypes: Record<string, any> = {};
+      const coreFunctions: Record<string, any> = {};
+      Object.values(coreModule.Packages).forEach((pkg: any) => {
+        if (pkg.Types) Object.assign(coreTypes, pkg.Types);
+        if (pkg.Functions) Object.assign(coreFunctions, pkg.Functions);
+      });
+
+      expect(coreTypes['Config']).toBeDefined();
+      expect(coreTypes['BaseService']).toBeDefined();
+      expect(coreFunctions['createConfig']).toBeDefined();
 
       // Verify UI module structure and dependencies
       const uiModule = result.Modules['@test/ui'];
       expect(uiModule).toBeDefined();
-      expect(uiModule.Packages.src).toBeDefined();
-      expect(uiModule.Packages.src.Types['UIService']).toBeDefined();
-      expect(uiModule.Packages.src.Types['ComponentProps']).toBeDefined();
-      expect(uiModule.Packages.src.Functions['createButton']).toBeDefined();
+
+      // Collect types and functions from all ui packages
+      const uiTypes: Record<string, any> = {};
+      const uiFunctions: Record<string, any> = {};
+      Object.values(uiModule.Packages).forEach((pkg: any) => {
+        if (pkg.Types) Object.assign(uiTypes, pkg.Types);
+        if (pkg.Functions) Object.assign(uiFunctions, pkg.Functions);
+      });
+
+      expect(uiTypes['UIService']).toBeDefined();
+      expect(uiTypes['ComponentProps']).toBeDefined();
+      expect(uiFunctions['createButton']).toBeDefined();
 
       // Verify cross-module dependencies in graph
       const graphKeys = Object.keys(result.Graph);
@@ -936,12 +970,26 @@ export class UserService {
 
       // Verify inheritance chains are captured
       const domainModule = result.Modules['@complex/domain'];
-      const userType = domainModule.Packages.src.Types['User'];
+
+      // Collect types from all domain packages
+      const domainTypes: Record<string, any> = {};
+      Object.values(domainModule.Packages).forEach((pkg: any) => {
+        if (pkg.Types) Object.assign(domainTypes, pkg.Types);
+      });
+
+      const userType = domainTypes['User'];
       expect(userType).toBeDefined();
       expect(userType.Exported).toBe(true);
 
       const serviceModule = result.Modules['@complex/service'];
-      const userServiceType = serviceModule.Packages.src.Types['UserService'];
+
+      // Collect types from all service packages
+      const serviceTypes: Record<string, any> = {};
+      Object.values(serviceModule.Packages).forEach((pkg: any) => {
+        if (pkg.Types) Object.assign(serviceTypes, pkg.Types);
+      });
+
+      const userServiceType = serviceTypes['UserService'];
       expect(userServiceType).toBeDefined();
 
       // Verify complex dependency graph
@@ -1218,7 +1266,7 @@ export const DEFAULT_VALUE = 'test';
           .mockImplementation(() => {});
 
         // Test without specifying monorepoMode (should default to combined)
-        const result = await parser.parseRepository(testProject.rootDir, {});
+        await parser.parseRepository(testProject.rootDir, {});
 
         // Verify combined mode was called (default behavior)
         expect(parseMonorepoCombinedModeSpy).toHaveBeenCalled();

ts-parser/src/types/typescript-mapping.md

@@ -12,25 +12,25 @@
 - **Dir**: Relative path from repository root
 - **Dependencies**: From `package.json` dependencies/devDependencies
 
-**Package (UNIAST) = TypeScript namespace/module**  
-- **Directory**: Source directory with TypeScript files
-- **PkgPath**: Import path (e.g., "@myorg/mypackage/utils", "./src/models")
-- **IsMain**: True for main entry point (index.ts)
-- **IsTest**: True for test files (*.test.ts, *.spec.ts)
+**Package (UNIAST) = Individual TypeScript/JavaScript file**
+- **File-based**: Each TypeScript/JavaScript file is a separate Package
+- **PkgPath**: File path relative to module root (e.g., "src/utils.ts", "src/models/user.ts")
+- **IsMain**: True for main entry point files (index.ts, main.ts)
+- **IsTest**: True for test files (*.test.ts, *.spec.ts, files in test/ or __tests__/)
 
 ### 2. Mapping Strategy
 
 ```
 Repository (root)
 ├── Module (npm package)
 │   ├── package.json
-│   ├── src/ (Package)
-│   │   ├── index.ts (IsMain=true)
-│   │   ├── utils.ts (PkgPath="./src/utils")
+│   ├── src/
+│   │   ├── index.ts (Package: PkgPath="src/index.ts", IsMain=true)
+│   │   ├── utils.ts (Package: PkgPath="src/utils.ts")
 │   │   └── models/
-│   │       └── user.ts (PkgPath="./src/models/user")
-│   └── test/ (Package)
-│       └── index.test.ts (IsTest=true)
+│   │       └── user.ts (Package: PkgPath="src/models/user.ts")
+│   └── test/
+│       └── index.test.ts (Package: PkgPath="test/index.test.ts", IsTest=true)
 └── node_modules/
     ├── lodash (Module - external)
     │   └── ...
@@ -41,30 +41,34 @@ Repository (root)
 ### 3. Package Path Resolution
 
 **Internal Packages**:
-- Relative to module root
-- Examples: "./src/utils", "./lib/helpers", "./test/mocks"
+- File path relative to module root
+- Examples: "src/utils.ts", "lib/helpers.ts", "test/mocks.ts"
 
 **External Packages**:
-- From node_modules
+- From node_modules, using module name
 - Examples: "lodash", "react", "@types/node"
 
 ### 4. File to Package Assignment
 
-Each TypeScript file belongs to a Package based on:
-1. **Directory structure** - Files in same directory = same package
-2. **Import statements** - Used to determine package boundaries
-3. **package.json exports** - Define public API boundaries
+**One File = One Package**:
+1. **File-level granularity** - Each TypeScript/JavaScript file constitutes a separate Package
+2. **PkgPath** - File's relative path from module root (with forward slashes on all platforms)
+3. **No directory grouping** - Files are not grouped by directory into packages
+4. **Independent parsing** - Each file is parsed independently as its own Package
 
 ### 5. Special Cases
 
 **Monorepos**:
 - Each workspace = separate Module
 - packages/app1, packages/lib1 = separate Modules
+- Each file within a workspace is a separate Package
 
 **Scoped packages**:
 - @myorg/package1 = Module with name "@myorg/package1"
 - @myorg/package2 = separate Module
+- Files within scoped packages follow the same file-level Package rule
 
 **TypeScript path mapping**:
-- tsconfig.json paths affect PkgPath resolution
-- "@/*": ["src/*"] → PkgPath="@/utils" maps to "./src/utils"
+- tsconfig.json paths affect module resolution during parsing
+- Actual PkgPath remains the physical file path relative to module root
+- Path aliases are resolved during symbol resolution, not for PkgPath naming

ts-parser/src/utils/parsing-strategy.ts

@@ -169,7 +169,7 @@ export class ParsingStrategySelector {
       tooManyFiles: totalFiles > this.THRESHOLDS.TOTAL_FILES_LARGE,
       tooLarge: totalSizeMB > this.THRESHOLDS.TOTAL_SIZE_LARGE_MB,
       tooManyPackages: packageCount > this.THRESHOLDS.PACKAGE_COUNT_LARGE,
-      hasLargePackages: hasLargePackages,
+      hasLargePackages,
       highAvgFiles: avgFilesPerPackage > this.THRESHOLDS.AVG_FILES_PER_PACKAGE,
       highMemoryUsage: estimatedMemoryUsageMB > this.THRESHOLDS.MEMORY_USAGE_LARGE_MB,
     };