@arcteninc/core 0.0.48 → 0.0.50

package/package.json

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

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

@@ -21,9 +21,11 @@ async function ensureGeneratorLoaded(): Promise<boolean> {
     // @ts-ignore - ts-json-schema-generator is optional
     tsJsonSchemaGeneratorModule = await import('ts-json-schema-generator');
     generatorAvailable = true;
+    console.log('✓ ts-json-schema-generator loaded successfully');
     return true;
   } catch (error) {
     tsJsonSchemaGeneratorModule = false; // Mark as failed
+    console.warn('⚠️  ts-json-schema-generator not available:', error);
     return false;
   }
 }
@@ -572,108 +574,41 @@ 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
+ * Handles interfaces, type aliases, classes, and enums
  */
 function getTypeInfoForGenerator(
   type: ts.Type,
-  checker: ts.TypeChecker,
-  paramSourceFile?: ts.SourceFile
+  checker: ts.TypeChecker
 ): { typeName: string; sourceFile: string } | null {
   const symbol = type.getSymbol();
-  
-  // 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 (!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, class, or enum
+  for (const decl of declarations) {
+    if (
+      ts.isTypeAliasDeclaration(decl) ||
+      ts.isInterfaceDeclaration(decl) ||
+      ts.isClassDeclaration(decl) ||
+      ts.isEnumDeclaration(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;
 }
 
@@ -695,17 +630,7 @@ async function serializeTypeWithGenerator(
     return null;
   }
 
-  // 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);
+  const typeInfo = getTypeInfoForGenerator(type, checker);
   if (!typeInfo) return null;
 
   try {
@@ -741,7 +666,8 @@ async function serializeTypeWithGenerator(
       schema: schemaWithoutDefs as JsonSchemaProperty,
     };
   } catch (error) {
-    // If generator fails, return null (will result in empty schema)
+    // If generator fails, log the error for debugging
+    console.warn(`⚠️  ts-json-schema-generator failed for type "${typeInfo.typeName}" from ${typeInfo.sourceFile}:`, error);
     return null;
   }
 }
@@ -749,39 +675,306 @@ async function serializeTypeWithGenerator(
 // Cache for generator results to avoid repeated calls
 const generatorCache = new Map<string, { isOptional: boolean; schema: JsonSchemaProperty }>();
 
+/**
+ * Custom serializer for anonymous types, enums, and object types
+ * This is a fallback when ts-json-schema-generator can't handle the type
+ */
+function serializeTypeCustom(
+  type: ts.Type,
+  checker: ts.TypeChecker,
+  defs?: Record<string, JsonSchemaProperty>,
+  visited = new Set<number>(),
+  depth = 0
+): { isOptional: boolean; schema: JsonSchemaProperty } {
+  // Prevent infinite recursion
+  if (depth > 10) {
+    return { isOptional: false, schema: {} };
+  }
+
+  const typeId = (type as any).id;
+  if (typeId !== undefined && visited.has(typeId)) {
+    return { isOptional: false, schema: {} };
+  }
+
+  if (typeId !== undefined) {
+    visited.add(typeId);
+  }
+
+  // Handle primitives first (safety net in case serializeType didn't catch them)
+  if (type.flags & ts.TypeFlags.String) {
+    return { isOptional: false, schema: { type: 'string' } };
+  }
+  if (type.flags & ts.TypeFlags.Number) {
+    return { isOptional: false, schema: { type: 'number' } };
+  }
+  if (type.flags & ts.TypeFlags.Boolean) {
+    return { isOptional: false, schema: { type: 'boolean' } };
+  }
+  if (type.flags & ts.TypeFlags.Null) {
+    return { isOptional: false, schema: { type: 'null' } };
+  }
+
+  // Handle string/number literals (enum values are often represented as literals)
+  if (type.flags & ts.TypeFlags.StringLiteral) {
+    const literalType = type as ts.StringLiteralType;
+    return { isOptional: false, schema: { type: 'string', const: literalType.value } };
+  }
+  if (type.flags & ts.TypeFlags.NumberLiteral) {
+    const literalType = type as ts.NumberLiteralType;
+    return { isOptional: false, schema: { type: 'number', const: literalType.value } };
+  }
+
+  // Handle enums (TypeScript enum types)
+  const symbol = type.getSymbol();
+  if (symbol) {
+    const declarations = symbol.getDeclarations();
+    if (declarations && declarations.length > 0) {
+      const firstDecl = declarations[0];
+      if (ts.isEnumDeclaration(firstDecl)) {
+        const enumMembers = firstDecl.members.map(m => {
+          if (m.initializer && ts.isStringLiteral(m.initializer)) {
+            return m.initializer.text;
+          } else if (m.initializer && ts.isNumericLiteral(m.initializer)) {
+            return Number(m.initializer.text);
+          } else if (m.name && ts.isIdentifier(m.name)) {
+            // For enum members without initializers, use the name
+            return m.name.text;
+          }
+          return null;
+        }).filter((v): v is string | number => v !== null);
+
+        if (enumMembers.length > 0) {
+          return { isOptional: false, schema: { enum: enumMembers } };
+        }
+      }
+      
+      // Handle interfaces and type aliases (for recursive types)
+      if (ts.isInterfaceDeclaration(firstDecl) || ts.isTypeAliasDeclaration(firstDecl)) {
+        const typeName = symbol.getName();
+        if (typeName && defs) {
+          const defsKey = typeName; // Use the type name as key
+          
+          // Check if we've visited this type before (circular/recursive reference)
+          if (visited.has(typeId)) {
+            // Create a reference to avoid infinite recursion
+            if (!defs[defsKey]) {
+              // Create placeholder - will be filled in below
+              defs[defsKey] = { type: 'object', properties: {} };
+            }
+            return { isOptional: false, schema: { $ref: `#/$defs/${defsKey}` } };
+          }
+          
+          // Check if already defined (from a previous call)
+          if (defs[defsKey]) {
+            return { isOptional: false, schema: { $ref: `#/$defs/${defsKey}` } };
+          }
+          
+          // Mark as visited and build the definition
+          visited.add(typeId);
+          
+          // Build the schema for this type
+          const props = checker.getPropertiesOfType(type);
+          if (props.length > 0) {
+            const properties: Record<string, JsonSchemaProperty> = {};
+            const required: string[] = [];
+            
+            // Use the same visited set for properties to detect recursion
+            for (const prop of props) {
+              const propName = prop.getName();
+              const propType = checker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration || prop.declarations?.[0] || checker.getDeclaredTypeOfSymbol(prop).symbol?.valueDeclaration || null as any);
+              const isOptional = (prop.flags & ts.SymbolFlags.Optional) !== 0;
+              
+              // Recursively serialize the property type (will detect recursion via visited set)
+              const propResult = serializeTypeCustom(propType, checker, defs, visited, depth + 1);
+              properties[propName] = propResult.schema;
+              
+              if (!isOptional && !propResult.isOptional) {
+                required.push(propName);
+              }
+            }
+            
+            const schema: JsonSchemaProperty = {
+              type: 'object',
+              properties,
+              ...(required.length > 0 && { required })
+            };
+            
+            // Store in defs
+            defs[defsKey] = schema;
+            
+            // Return reference
+            return { isOptional: false, schema: { $ref: `#/$defs/${defsKey}` } };
+          }
+        }
+      }
+    }
+  }
+
+  // Handle object types with properties (anonymous types)
+  if (type.flags & ts.TypeFlags.Object) {
+    const props = checker.getPropertiesOfType(type);
+    if (props.length > 0) {
+      const properties: Record<string, JsonSchemaProperty> = {};
+      const required: string[] = [];
+
+      for (const prop of props) {
+        const propName = prop.getName();
+        const propType = checker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration || prop.declarations?.[0] || checker.getDeclaredTypeOfSymbol(prop).symbol?.valueDeclaration || null as any);
+        const isOptional = (prop.flags & ts.SymbolFlags.Optional) !== 0;
+
+        // Recursively serialize the property type
+        const propResult = serializeTypeCustom(propType, checker, defs, new Set(visited), depth + 1);
+        properties[propName] = propResult.schema;
+
+        if (!isOptional && !propResult.isOptional) {
+          required.push(propName);
+        }
+      }
+
+      return {
+        isOptional: false,
+        schema: {
+          type: 'object',
+          properties,
+          ...(required.length > 0 && { required })
+        }
+      };
+    }
+  }
+
+  // Fallback to empty schema
+  return { isOptional: false, schema: {} };
+}
+
 /**
  * Serialize a TypeScript type to JSON Schema format using ts-json-schema-generator
- * Only works for named types (interfaces, type aliases, classes)
- * Returns empty schema for anonymous types
+ * Handles primitives, arrays, and named types (interfaces, type aliases, classes, enums)
  */
 async function serializeType(
   type: ts.Type,
   checker: ts.TypeChecker,
   program: ts.Program | undefined,
   configPath: string | undefined,
-  defs?: Record<string, JsonSchemaProperty>,
-  sourceFileForLookup?: ts.SourceFile
+  defs?: Record<string, JsonSchemaProperty>
 ): Promise<{ isOptional: boolean; schema: JsonSchemaProperty }> {
-  if (!program || !configPath) {
-    return { isOptional: false, schema: {} }; // Empty schema = any value
+  // Handle primitives first (these don't need the generator)
+  if (type.flags & ts.TypeFlags.String) {
+    return { isOptional: false, schema: { type: 'string' } };
+  }
+  if (type.flags & ts.TypeFlags.Number) {
+    return { isOptional: false, schema: { type: 'number' } };
+  }
+  if (type.flags & ts.TypeFlags.Boolean) {
+    return { isOptional: false, schema: { type: 'boolean' } };
+  }
+  if (type.flags & ts.TypeFlags.Null) {
+    return { isOptional: false, schema: { type: 'null' } };
+  }
+  if (type.flags & ts.TypeFlags.Undefined || type.flags & ts.TypeFlags.Void) {
+    return { isOptional: true, schema: { type: 'null' } };
   }
 
-  // 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];
+  // Handle string/number literals (enum values are often represented as literals)
+  if (type.flags & ts.TypeFlags.StringLiteral) {
+    const literalType = type as ts.StringLiteralType;
+    return { isOptional: false, schema: { type: 'string', const: literalType.value } };
+  }
+  if (type.flags & ts.TypeFlags.NumberLiteral) {
+    const literalType = type as ts.NumberLiteralType;
+    return { isOptional: false, schema: { type: 'number', const: literalType.value } };
+  }
+
+  // Handle arrays
+  if (checker.isArrayType(type)) {
+    const typeArgs = (type as ts.TypeReference).typeArguments;
+    if (typeArgs && typeArgs.length > 0) {
+      const itemResult = await serializeType(typeArgs[0], checker, program, configPath, defs);
+      return {
+        isOptional: false,
+        schema: { type: 'array', items: itemResult.schema }
+      };
     }
+    return { isOptional: false, schema: { type: 'array' } };
   }
-  
-  const typeInfo = getTypeInfoForGenerator(type, checker, lookupFile);
+
+  // Handle union types (like string | null)
+  if (type.isUnion()) {
+    const types = type.types;
+    const hasNull = types.some(t => t.flags & ts.TypeFlags.Null);
+    const hasUndefined = types.some(t => t.flags & ts.TypeFlags.Undefined);
+    const nonNullUndefinedTypes = types.filter(
+      t => !(t.flags & ts.TypeFlags.Null) && !(t.flags & ts.TypeFlags.Undefined)
+    );
+
+    // If it's just T | undefined, make it optional
+    if (hasUndefined && nonNullUndefinedTypes.length === 1 && !hasNull) {
+      const result = await serializeType(nonNullUndefinedTypes[0], checker, program, configPath, defs);
+      return { isOptional: true, schema: result.schema };
+    }
+
+    // Check if union is all string/number literals (enum-like union)
+    // This handles cases where TypeScript represents enums as unions of literals
+    const allStringLiterals = nonNullUndefinedTypes.every(t => t.flags & ts.TypeFlags.StringLiteral);
+    const allNumberLiterals = nonNullUndefinedTypes.every(t => t.flags & ts.TypeFlags.NumberLiteral);
+    
+    if (allStringLiterals && nonNullUndefinedTypes.length > 0) {
+      const enumValues = nonNullUndefinedTypes.map(t => {
+        const literalType = t as ts.StringLiteralType;
+        return literalType.value;
+      });
+      const schema: JsonSchemaProperty = { enum: enumValues };
+      return { isOptional: hasNull || hasUndefined, schema };
+    }
+    
+    if (allNumberLiterals && nonNullUndefinedTypes.length > 0) {
+      const enumValues = nonNullUndefinedTypes.map(t => {
+        const literalType = t as ts.NumberLiteralType;
+        return literalType.value;
+      });
+      const schema: JsonSchemaProperty = { enum: enumValues };
+      return { isOptional: hasNull || hasUndefined, schema };
+    }
+
+    // Build anyOf for unions
+    if (nonNullUndefinedTypes.length > 0 || hasNull) {
+      const anyOf: JsonSchemaProperty[] = [];
+      if (hasNull || hasUndefined) {
+        anyOf.push({ type: 'null' });
+      }
+      for (const unionType of nonNullUndefinedTypes) {
+        const result = await serializeType(unionType, checker, program, configPath, defs);
+        anyOf.push(result.schema);
+      }
+      if (anyOf.length === 1) {
+        return { isOptional: hasNull || hasUndefined, schema: anyOf[0] };
+      }
+      return { isOptional: false, schema: { anyOf } };
+    }
+  }
+
+  // Check if it's an enum - handle with custom serializer first
+  const symbol = type.getSymbol();
+  if (symbol) {
+    const declarations = symbol.getDeclarations();
+    if (declarations && declarations.length > 0) {
+      const firstDecl = declarations[0];
+      if (ts.isEnumDeclaration(firstDecl)) {
+        // Use custom serializer for enums (more reliable)
+        return serializeTypeCustom(type, checker, defs);
+      }
+    }
+  }
+
+  // For named types (interfaces, type aliases, classes), try generator first
+  if (!program || !configPath) {
+    // No program/config - use custom serializer
+    return serializeTypeCustom(type, checker, defs);
+  }
+
+  const typeInfo = getTypeInfoForGenerator(type, checker);
   if (!typeInfo) {
-    // Anonymous/inline type - can't serialize with generator
-    return { isOptional: false, schema: {} }; // Empty schema = any value
+    // Anonymous/inline type - use custom serializer
+    return serializeTypeCustom(type, checker, defs);
   }
 
   // Check cache first
@@ -790,15 +983,16 @@ async function serializeType(
     return generatorCache.get(cacheKey)!;
   }
 
-  // Use generator
+  // Use generator for named types
   const result = await serializeTypeWithGenerator(type, checker, program, configPath, defs);
   if (result) {
     generatorCache.set(cacheKey, result);
     return result;
   }
 
-  // Generator failed - return empty schema
-  return { isOptional: false, schema: {} }; // Empty schema = any value
+  // Generator failed - fall back to custom serializer
+  console.warn(`⚠️  Failed to generate schema for type "${typeInfo.typeName}" from ${typeInfo.sourceFile}. Falling back to custom serializer.`);
+  return serializeTypeCustom(type, checker, defs);
 }
 
 /**
@@ -999,8 +1193,7 @@ async function extractFunctionMetadata(
       
       // Use ts-json-schema-generator for named types only
       // Anonymous types are not supported - agents can't use them anyway
-      // Pass sourceFile to help resolve anonymous types to named types
-      const result = await serializeType(type, checker, program, configPath, defs, sourceFile);
+      const result = await serializeType(type, checker, program, configPath, defs);
       propSchema = result.schema;
       isOptional = result.isOptional;
     } else {