@arcteninc/core 0.0.47 → 0.0.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcteninc/core",
-  "version": "0.0.47",
+  "version": "0.0.48",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",

package/scripts/cli-extract-types-auto.ts

@@ -572,39 +572,108 @@ function resolveImportPath(
   return null;
 }
 
+/**
+ * Try to resolve an anonymous type to a named type by checking structural compatibility
+ * This helps when function parameters use anonymous types that match existing interfaces
+ */
+function tryResolveToNamedType(
+  type: ts.Type,
+  checker: ts.TypeChecker,
+  sourceFile: ts.SourceFile
+): { typeName: string; sourceFile: string } | null {
+  // Only try for object types
+  if (!(type.flags & ts.TypeFlags.Object)) return null;
+  
+  const props = checker.getPropertiesOfType(type);
+  if (props.length === 0) return null;
+  
+  // Get all exported interfaces/types from the same file
+  const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+  if (!moduleSymbol) return null;
+  
+  const fileSymbols = checker.getExportsOfModule(moduleSymbol);
+  if (!fileSymbols || fileSymbols.length === 0) return null;
+  
+  // Check each exported type/interface to see if it matches structurally
+  for (const symbol of fileSymbols) {
+    if (!symbol) continue;
+    
+    const name = symbol.getName();
+    if (!name || name.length === 0) continue;
+    
+    const declarations = symbol.getDeclarations();
+    if (!declarations || declarations.length === 0) continue;
+    
+    for (const decl of declarations) {
+      if (ts.isInterfaceDeclaration(decl) || ts.isTypeAliasDeclaration(decl)) {
+        // Get the type from the declaration
+        const declaredType = checker.getTypeAtLocation(decl);
+        
+        // Check if properties match (simple structural check)
+        const declaredProps = checker.getPropertiesOfType(declaredType);
+        if (declaredProps.length === props.length) {
+          // Check if all property names match
+          const propNames = new Set(props.map(p => p.getName()));
+          const declaredPropNames = new Set(declaredProps.map(p => p.getName()));
+          
+          if (propNames.size === declaredPropNames.size &&
+              [...propNames].every(n => declaredPropNames.has(n))) {
+            // Properties match - this might be the same type
+            return {
+              typeName: name,
+              sourceFile: sourceFile.fileName,
+            };
+          }
+        }
+      }
+    }
+  }
+  
+  return null;
+}
+
 /**
  * Try to get type name and source file for use with ts-json-schema-generator
  */
 function getTypeInfoForGenerator(
   type: ts.Type,
-  checker: ts.TypeChecker
+  checker: ts.TypeChecker,
+  paramSourceFile?: ts.SourceFile
 ): { typeName: string; sourceFile: string } | null {
   const symbol = type.getSymbol();
-  if (!symbol) return null;
-
-  const name = symbol.getName();
-  if (!name || name.length === 0) return null;
-
-  const declarations = symbol.getDeclarations();
-  if (!declarations || declarations.length === 0) return null;
-
-  // Find the first declaration that's a type alias, interface, or class
-  for (const decl of declarations) {
-    if (
-      ts.isTypeAliasDeclaration(decl) ||
-      ts.isInterfaceDeclaration(decl) ||
-      ts.isClassDeclaration(decl)
-    ) {
-      const sourceFile = decl.getSourceFile();
-      if (sourceFile) {
-        return {
-          typeName: name,
-          sourceFile: sourceFile.fileName,
-        };
+  
+  // If it's a named type, use it directly
+  if (symbol) {
+    const name = symbol.getName();
+    if (name && name.length > 0) {
+      const declarations = symbol.getDeclarations();
+      if (declarations && declarations.length > 0) {
+        // Find the first declaration that's a type alias, interface, or class
+        for (const decl of declarations) {
+          if (
+            ts.isTypeAliasDeclaration(decl) ||
+            ts.isInterfaceDeclaration(decl) ||
+            ts.isClassDeclaration(decl)
+          ) {
+            const sourceFile = decl.getSourceFile();
+            if (sourceFile) {
+              return {
+                typeName: name,
+                sourceFile: sourceFile.fileName,
+              };
+            }
+          }
+        }
       }
     }
   }
-
+  
+  // If it's an anonymous type, try to resolve it to a named type
+  if (paramSourceFile) {
+    const resolved = tryResolveToNamedType(type, checker, paramSourceFile);
+    if (resolved) return resolved;
+  }
+  
   return null;
 }
 
@@ -626,7 +695,17 @@ async function serializeTypeWithGenerator(
     return null;
   }
 
-  const typeInfo = getTypeInfoForGenerator(type, checker);
+  // Try to get source file from the type's declarations or use a fallback
+  let sourceFileForLookup: ts.SourceFile | undefined;
+  const symbol = type.getSymbol();
+  if (symbol) {
+    const declarations = symbol.getDeclarations();
+    if (declarations && declarations.length > 0) {
+      sourceFileForLookup = declarations[0].getSourceFile();
+    }
+  }
+  
+  const typeInfo = getTypeInfoForGenerator(type, checker, sourceFileForLookup);
   if (!typeInfo) return null;
 
   try {
@@ -680,13 +759,26 @@ async function serializeType(
   checker: ts.TypeChecker,
   program: ts.Program | undefined,
   configPath: string | undefined,
-  defs?: Record<string, JsonSchemaProperty>
+  defs?: Record<string, JsonSchemaProperty>,
+  sourceFileForLookup?: ts.SourceFile
 ): Promise<{ isOptional: boolean; schema: JsonSchemaProperty }> {
   if (!program || !configPath) {
     return { isOptional: false, schema: {} }; // Empty schema = any value
   }
 
-  const typeInfo = getTypeInfoForGenerator(type, checker);
+  // Use provided sourceFileForLookup or try to find one from program
+  let lookupFile = sourceFileForLookup;
+  if (!lookupFile && program) {
+    // Try to find a source file that might contain the type
+    // This is a best-effort approach for anonymous types
+    const sourceFiles = program.getSourceFiles();
+    if (sourceFiles.length > 0) {
+      // Use the first source file as a fallback (could be improved)
+      lookupFile = sourceFiles[0];
+    }
+  }
+  
+  const typeInfo = getTypeInfoForGenerator(type, checker, lookupFile);
   if (!typeInfo) {
     // Anonymous/inline type - can't serialize with generator
     return { isOptional: false, schema: {} }; // Empty schema = any value
@@ -907,7 +999,8 @@ async function extractFunctionMetadata(
       
       // Use ts-json-schema-generator for named types only
       // Anonymous types are not supported - agents can't use them anyway
-      const result = await serializeType(type, checker, program, configPath, defs);
+      // Pass sourceFile to help resolve anonymous types to named types
+      const result = await serializeType(type, checker, program, configPath, defs, sourceFile);
       propSchema = result.schema;
       isOptional = result.isOptional;
     } else {