@arcteninc/core 0.0.32 → 0.0.34

package/package.json

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

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

@@ -35,10 +35,10 @@ async function main() {
   }
 
   const args = process.argv.slice(2);
-  
+
   // Check for bun first (faster and preferred if available)
   const hasBun = await checkCommand('bun');
-  
+
   if (hasBun) {
     // Use bun directly - it's faster and can run TypeScript natively
     const bunProcess = spawn('bun', [tsScript, ...args], {
@@ -62,7 +62,7 @@ async function main() {
 
 async function tryTsxFallback(args) {
   const hasNpx = await checkCommand('npx');
-  
+
   if (hasNpx) {
     // Use tsx via npx - it's lightweight and works great with Node.js
     const tsxProcess = spawn('npx', ['-y', 'tsx', tsScript, ...args], {

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

@@ -14,7 +14,8 @@ interface JsonSchemaProperty {
   type?: string | string[]; // Can be string, array of strings, or omitted for anyOf/oneOf/$ref
   description?: string;
   default?: string;
-  enum?: string[]; // For enum types
+  enum?: (string | number)[]; // For enum types (can be string or number enums)
+  const?: string | number | boolean; // For literal values
   items?: JsonSchemaProperty; // For array types
   properties?: Record<string, JsonSchemaProperty>; // For object types
   required?: string[]; // For nested objects
@@ -90,20 +91,34 @@ function extractToolNamesFromExpression(
             toolNames.add(element.name.getText(sourceFile));
           }
           // For arrow functions without names, skip them
-        } else {
-          const name = element.getText(sourceFile).trim();
-          // Remove any object property access (e.g., tools.getOrders -> getOrders)
-          const simpleName = name.split('.').pop() || name;
-          // Skip if it looks like code (contains operators, semicolons, etc.)
-          if (simpleName && 
-              simpleName !== 'undefined' && 
-              simpleName !== 'null' &&
-              !simpleName.includes('?') &&
-              !simpleName.includes(';') &&
-              !simpleName.includes('=>') &&
-              simpleName.length < 100) {
-            toolNames.add(simpleName);
+        } else if (ts.isIdentifier(element)) {
+          // Direct identifier: toolName
+          const name = element.text;
+          if (name && name !== 'undefined' && name !== 'null') {
+            toolNames.add(name);
+          }
+        } else if (ts.isPropertyAccessExpression(element)) {
+          // Property access: tools.getOrders -> extract "getOrders"
+          const propName = element.name.text;
+          if (propName) {
+            toolNames.add(propName);
           }
+        } else if (ts.isElementAccessExpression(element)) {
+          // Element access: tools['getOrders'] -> extract the property name if it's a string literal
+          const indexExpr = element.argumentExpression;
+          if (ts.isStringLiteral(indexExpr) || ts.isNumericLiteral(indexExpr)) {
+            const name = indexExpr.text;
+            if (name && name !== 'undefined' && name !== 'null') {
+              toolNames.add(name);
+            }
+          } else {
+            // For dynamic access like tools[someVar], recursively extract
+            extractFromExpr(indexExpr);
+          }
+        } else {
+          // For other expression types, try to extract recursively
+          // This handles cases like: [(someCondition ? tool1 : tool2)]
+          extractFromExpr(element);
         }
       }
       return;
@@ -111,7 +126,7 @@ function extractToolNamesFromExpression(
 
     // Variable reference: toolsList or function name: generateReport
     if (ts.isIdentifier(node)) {
-      const varName = node.getText(sourceFile);
+      const varName = node.text;
       const varExpr = variableMap.get(varName);
       if (varExpr) {
         extractFromExpr(varExpr);
@@ -127,7 +142,7 @@ function extractToolNamesFromExpression(
 
     // Property access: wrappedTools.getRAGInfo
     if (ts.isPropertyAccessExpression(node)) {
-      const propName = node.name.getText(sourceFile);
+      const propName = node.name.text;
       toolNames.add(propName);
       return;
     }
@@ -136,7 +151,7 @@ function extractToolNamesFromExpression(
     if (ts.isCallExpression(node)) {
       const callExpr = node.expression;
       if (ts.isIdentifier(callExpr)) {
-        const funcName = callExpr.getText(sourceFile);
+        const funcName = callExpr.text;
         if (funcName === 'useMemo' && node.arguments.length > 0) {
           const firstArg = node.arguments[0];
           // Arrow function: () => [...]
@@ -369,7 +384,7 @@ function findFunctionDefinition(
 
   // Follow imports to find definition
   for (const imp of imports) {
-    const resolvedPath = resolveImportPath(imp.from, sourceFile.fileName);
+    const resolvedPath = resolveImportPath(imp.from, sourceFile.fileName, program);
     if (resolvedPath) {
       const importedSourceFile = program.getSourceFile(resolvedPath);
       if (importedSourceFile) {
@@ -385,16 +400,81 @@ function findFunctionDefinition(
 }
 
 /**
- * Resolve import path to actual file path
+ * Resolve import path to actual file path using TypeScript's module resolution
  */
-function resolveImportPath(importPath: string, fromFile: string): string | null {
+function resolveImportPath(
+  importPath: string,
+  fromFile: string,
+  program: ts.Program
+): string | null {
+  const compilerOptions = program.getCompilerOptions();
+  
+  // Create a minimal module resolution host
+  const host: ts.ModuleResolutionHost = {
+    fileExists: (fileName: string) => {
+      try {
+        return fs.existsSync(fileName) && fs.statSync(fileName).isFile();
+      } catch {
+        return false;
+      }
+    },
+    readFile: (fileName: string) => {
+      try {
+        return fs.readFileSync(fileName, 'utf8');
+      } catch {
+        return undefined;
+      }
+    },
+    directoryExists: (directoryName: string) => {
+      try {
+        return fs.existsSync(directoryName) && fs.statSync(directoryName).isDirectory();
+      } catch {
+        return false;
+      }
+    },
+    getCurrentDirectory: () => path.dirname(fromFile),
+    getDirectories: (pathName: string) => {
+      try {
+        return fs.readdirSync(pathName).filter(name => {
+          const fullPath = path.join(pathName, name);
+          try {
+            return fs.statSync(fullPath).isDirectory();
+          } catch {
+            return false;
+          }
+        });
+      } catch {
+        return [];
+      }
+    },
+    realpath: (pathName: string) => {
+      try {
+        return fs.realpathSync(pathName);
+      } catch {
+        return pathName;
+      }
+    },
+    useCaseSensitiveFileNames: () => process.platform !== 'win32',
+  };
+
+  // Use TypeScript's module resolution
+  const resolved = ts.resolveModuleName(
+    importPath,
+    fromFile,
+    compilerOptions,
+    host
+  );
+
+  if (resolved.resolvedModule) {
+    return resolved.resolvedModule.resolvedFileName;
+  }
+
+  // Fallback: try manual resolution for relative paths
   if (importPath.startsWith('.')) {
-    // Relative import
     const dir = path.dirname(fromFile);
     const resolved = path.resolve(dir, importPath);
-
-    // Try common extensions
-    const extensions = ['.ts', '.tsx', '.js', '.jsx'];
+    const extensions = ['.ts', '.tsx', '.js', '.jsx', '.d.ts'];
+    
     for (const ext of extensions) {
       const withExt = resolved + ext;
       if (fs.existsSync(withExt)) {
@@ -409,11 +489,197 @@ function resolveImportPath(importPath: string, fromFile: string): string | null
         return indexPath;
       }
     }
+  }
+
+  return null;
+}
+
+// Constants for JSON Schema validation
+// These are actual constants from the JSON Schema specification
+const VALID_JSON_SCHEMA_TYPES = new Set(['string', 'number', 'integer', 'boolean', 'object', 'array', 'null']);
+
+// Safety limit for serialization depth (only used as a last resort)
+// Note: Cycle detection via 'visited' Set is the primary protection against infinite recursion
+// This is only a fallback safety net for edge cases
+const MAX_SERIALIZATION_DEPTH = 50; // Increased from 10 - legitimate types can be deeply nested
+
+// Note: MAX_TOOL_NAME_LENGTH was removed - we now use proper AST node type checks
+// instead of string length heuristics for better accuracy
+
+/**
+ * Type-safe accessors for TypeScript internal APIs
+ * These use type guards to safely access properties that aren't in the public API
+ */
+
+interface BooleanLiteralType extends ts.Type {
+  intrinsicName: 'true' | 'false';
+}
+
+interface NumberLiteralType extends ts.Type {
+  value: number;
+}
+
+interface StringLiteralType extends ts.Type {
+  value: string;
+}
+
+/**
+ * Get boolean literal value from a TypeScript type
+ */
+function getBooleanLiteralValue(type: ts.Type): boolean | null {
+  if (type.flags & ts.TypeFlags.BooleanLiteral) {
+    const boolType = type as BooleanLiteralType;
+    return boolType.intrinsicName === 'true';
+  }
+  return null;
+}
+
+/**
+ * Get number literal value from a TypeScript type
+ */
+function getNumberLiteralValue(type: ts.Type): number | null {
+  if (type.flags & ts.TypeFlags.NumberLiteral) {
+    const numType = type as NumberLiteralType;
+    return numType.value;
+  }
+  return null;
+}
+
+/**
+ * Get string literal value from a TypeScript type
+ */
+function getStringLiteralValue(type: ts.Type): string | null {
+  if (type.flags & ts.TypeFlags.StringLiteral) {
+    const strType = type as StringLiteralType;
+    return strType.value;
+  }
+  return null;
+}
+
+/**
+ * Get type ID safely (for cycle detection)
+ * Uses TypeScript's internal API - this is necessary for cycle detection
+ * but we wrap it in a function to centralize the unsafe access
+ */
+function getTypeId(type: ts.Type): number | undefined {
+  // TypeScript's Type interface doesn't expose 'id' in public API,
+  // but it's available internally and needed for cycle detection.
+  // This is a known limitation when working with TypeScript's compiler API.
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return (type as any).id;
+}
+
+/**
+ * Serialize a literal type (boolean, number, or string literal) to JSON Schema
+ * Returns null if the type is not a literal
+ */
+function serializeLiteralType(type: ts.Type): JsonSchemaProperty | null {
+  const boolValue = getBooleanLiteralValue(type);
+  if (boolValue !== null) {
+    return { type: 'boolean', const: boolValue };
+  }
+  
+  const numValue = getNumberLiteralValue(type);
+  if (numValue !== null) {
+    return { type: 'number', const: numValue };
+  }
+  
+  const strValue = getStringLiteralValue(type);
+  if (strValue !== null) {
+    return { type: 'string', const: strValue };
+  }
+  
+  return null;
+}
+
+/**
+ * Check if a type is a type reference (named type like FilterTreeNode)
+ * Uses TypeScript API to determine if it's a named type reference
+ */
+function isTypeReference(type: ts.Type, checker: ts.TypeChecker): boolean {
+  const symbol = type.getSymbol();
+  if (!symbol) return false;
+  
+  const name = symbol.getName();
+  if (name.length === 0) return false;
+  
+  // Check if it's a primitive JSON Schema type (should not be treated as type reference)
+  if (VALID_JSON_SCHEMA_TYPES.has(name.toLowerCase())) {
+    return false;
+  }
+  
+  // Check if it's a named type (has declarations and is not a primitive)
+  const declarations = symbol.getDeclarations();
+  if (!declarations || declarations.length === 0) return false;
+  
+  // Check if any declaration is a type alias, interface, or class
+  // This is more reliable than regex pattern matching
+  for (const decl of declarations) {
+    if (
+      ts.isTypeAliasDeclaration(decl) ||
+      ts.isInterfaceDeclaration(decl) ||
+      ts.isClassDeclaration(decl) ||
+      ts.isEnumDeclaration(decl)
+    ) {
+      // Additional check: PascalCase convention (first letter uppercase)
+      // This helps distinguish type references from variables/functions
+      const firstChar = name.charAt(0);
+      return firstChar >= 'A' && firstChar <= 'Z';
+    }
+  }
+  
+  return false;
+}
+
+/**
+ * Check if a schema is a fallback 'any' (not a real schema)
+ * Uses type checking instead of string length heuristics
+ */
+function isFallbackAnySchema(
+  schema: JsonSchemaProperty, 
+  type: ts.Type,
+  checker: ts.TypeChecker
+): boolean {
+  // If it's not 'any', it's a real schema
+  if (schema.type !== 'any') {
+    return false;
+  }
+  
+  // If it has properties, anyOf, or items, it's a real schema
+  if (schema.properties || schema.anyOf || schema.items) {
+    return false;
+  }
+  
+  // Check if it's actually a type reference we couldn't resolve
+  // (not a primitive, not an object we processed, etc.)
+  return isTypeReference(type, checker);
+}
 
-    return resolved;
+/**
+ * Resolve type references (type aliases, interfaces) to their actual types
+ */
+function resolveTypeReference(
+  type: ts.Type,
+  checker: ts.TypeChecker
+): ts.Type | null {
+  const symbol = type.getSymbol();
+  if (!symbol) return null;
+
+  const declarations = symbol.getDeclarations();
+  if (!declarations || declarations.length === 0) return null;
+
+  // Try to get the actual type from the declaration
+  for (const decl of declarations) {
+    if (ts.isTypeAliasDeclaration(decl) && decl.type) {
+      // Resolve the type alias
+      return checker.getTypeFromTypeNode(decl.type);
+    }
+    if (ts.isInterfaceDeclaration(decl)) {
+      // Get the interface type
+      return checker.getTypeAtLocation(decl);
+    }
   }
 
-  // Node modules - we'll skip for now
   return null;
 }
 
@@ -428,12 +694,12 @@ function serializeType(
   depth = 0
 ): { isOptional: boolean; schema: JsonSchemaProperty } {
   const typeString = checker.typeToString(type);
-
-  if (depth > 10) {
+  
+  if (depth > MAX_SERIALIZATION_DEPTH) {
     return { isOptional: false, schema: { type: 'any' } };
   }
 
-  const typeId = (type as any).id;
+  const typeId = getTypeId(type);
   if (typeId !== undefined && visited.has(typeId)) {
     return { isOptional: false, schema: { type: 'any' } };
   }
@@ -448,6 +714,13 @@ function serializeType(
   if (type.flags & ts.TypeFlags.Boolean) {
     return { isOptional: false, schema: { type: 'boolean' } };
   }
+  
+  // Handle literals using helper function
+  const literalSchema = serializeLiteralType(type);
+  if (literalSchema) {
+    return { isOptional: false, schema: literalSchema };
+  }
+  
   if (type.flags & ts.TypeFlags.Undefined || type.flags & ts.TypeFlags.Void) {
     return { isOptional: true, schema: { type: 'null' } };
   }
@@ -465,8 +738,8 @@ function serializeType(
 
     // Check if it's a string literal union (enum) - possibly with null/undefined
     const stringLiterals = nonNullUndefinedTypes
-      .filter(t => t.flags & ts.TypeFlags.StringLiteral)
-      .map(t => (t as ts.StringLiteralType).value);
+      .map(t => getStringLiteralValue(t))
+      .filter((v): v is string => v !== null);
 
     // If all non-null/undefined types are string literals, use enum
     if (stringLiterals.length > 0 && stringLiterals.length === nonNullUndefinedTypes.length) {
@@ -514,7 +787,12 @@ function serializeType(
         anyOf.push({ type: 'number' });
       } else if (unionType.flags & ts.TypeFlags.Boolean) {
         anyOf.push({ type: 'boolean' });
-      } else if (checker.isArrayType(unionType)) {
+      } else {
+        // Try literal types first (using helper function)
+        const literalSchema = serializeLiteralType(unionType);
+        if (literalSchema) {
+          anyOf.push(literalSchema);
+        } else if (checker.isArrayType(unionType)) {
         // Handle array types
         const typeArgs = (unionType as ts.TypeReference).typeArguments;
         if (typeArgs && typeArgs.length > 0) {
@@ -523,42 +801,40 @@ function serializeType(
         } else {
           anyOf.push({ type: 'array' });
         }
-      } else {
-        // Try to serialize the type (handles objects, type references, etc.)
-        // This will recursively resolve type aliases and interfaces
-        try {
-          const refResult = serializeType(unionType, checker, visited, depth + 1);
-          
-          // Check if we got a valid schema (not just 'any' fallback)
-          const typeString = checker.typeToString(unionType);
-          const isFallbackAny = refResult.schema.type === 'any' && 
-                                 !refResult.schema.properties && 
-                                 !refResult.schema.anyOf &&
-                                 !refResult.schema.items &&
-                                 typeString.length < 100; // If type string is short, it's probably a simple reference
-          
-          if (!isFallbackAny) {
-            anyOf.push(refResult.schema);
-          } else {
-            // For type references we can't fully resolve (like FilterTreeNode),
-            // check if it's a named type that might be defined elsewhere
-            // For now, we'll use 'any' but in a more advanced version,
-            // we'd track these and generate $defs or inline them
-            // Check if it looks like a type reference (starts with capital, no special chars)
-            if (/^[A-Z][a-zA-Z0-9]*$/.test(typeString)) {
-              // It's a type reference - use any for now
-              // TODO: Resolve and inline type definitions or use $ref with $defs
-              anyOf.push({ type: 'any' });
-            } else {
-              // It's something else - try to use the serialized result anyway
+        } else {
+          // Try to serialize the type (handles objects, type references, etc.)
+          // This will recursively resolve type aliases and interfaces
+          try {
+            const refResult = serializeType(unionType, checker, visited, depth + 1);
+            
+            // Check if we got a valid schema (not just 'any' fallback)
+            if (!isFallbackAnySchema(refResult.schema, unionType, checker)) {
               anyOf.push(refResult.schema);
+            } else {
+              // Try to resolve type reference before giving up
+              const resolvedType = resolveTypeReference(unionType, checker);
+              if (resolvedType) {
+                try {
+                  const resolvedResult = serializeType(resolvedType, checker, visited, depth + 1);
+                  if (!isFallbackAnySchema(resolvedResult.schema, resolvedType, checker)) {
+                    anyOf.push(resolvedResult.schema);
+                  } else {
+                    anyOf.push({ type: 'any' });
+                  }
+                } catch (error) {
+                  anyOf.push({ type: 'any' });
+                }
+              } else {
+                // It's a type reference we couldn't fully resolve - use 'any'
+                anyOf.push({ type: 'any' });
+              }
             }
+          } catch (error) {
+            // Fallback for unresolvable types
+            const unionTypeString = checker.typeToString(unionType);
+            console.warn(`Warning: Could not serialize union type: ${unionTypeString}`, error);
+            anyOf.push({ type: 'any' });
           }
-        } catch (e) {
-          // Fallback for unresolvable types
-          const typeString = checker.typeToString(unionType);
-          console.warn(`Warning: Could not serialize union type: ${typeString}`, e);
-          anyOf.push({ type: 'any' });
         }
       }
     }
@@ -591,6 +867,34 @@ function serializeType(
     };
   }
 
+  // Handle intersection types (A & B)
+  if (type.isIntersection()) {
+    const types = type.types;
+    const allProperties: Record<string, JsonSchemaProperty> = {};
+    const allRequired: string[] = [];
+
+    for (const intersectionType of types) {
+      const result = serializeType(intersectionType, checker, visited, depth + 1);
+      if (result.schema.type === 'object' && result.schema.properties) {
+        Object.assign(allProperties, result.schema.properties);
+        if (result.schema.required) {
+          allRequired.push(...result.schema.required);
+        }
+      }
+    }
+
+    if (Object.keys(allProperties).length > 0) {
+      return {
+        isOptional: false,
+        schema: {
+          type: 'object',
+          properties: allProperties,
+          required: Array.from(new Set(allRequired))
+        }
+      };
+    }
+  }
+
   // Handle arrays
   if (checker.isArrayType(type)) {
     const typeArgs = (type as ts.TypeReference).typeArguments;
@@ -616,9 +920,14 @@ function serializeType(
 
     if (props.length > 0) {
       for (const prop of props) {
-        const propDeclaration = prop.valueDeclaration || prop.declarations?.[0];
+        try {
+          const propDeclaration = prop.valueDeclaration || prop.declarations?.[0];
+
+          if (!propDeclaration) {
+            // Skip properties without declarations
+            continue;
+          }
 
-        if (propDeclaration) {
           const propType = checker.getTypeOfSymbolAtLocation(prop, propDeclaration);
           const isOptional = (prop.flags & ts.SymbolFlags.Optional) !== 0;
 
@@ -629,6 +938,31 @@ function serializeType(
           if (!isOptional && !propResult.isOptional) {
             required.push(prop.name);
           }
+        } catch (error) {
+          // Skip properties that can't be serialized
+          console.warn(`Warning: Could not serialize property ${prop.name}`, error);
+        }
+      }
+
+      // Extract index signatures ([key: string]: T)
+      const indexSignatures = checker.getIndexInfosOfType(type);
+      if (indexSignatures && indexSignatures.length > 0) {
+        try {
+          const indexInfo = indexSignatures[0];
+          if (indexInfo.declaration) {
+            const indexType = checker.getTypeAtLocation(indexInfo.declaration);
+            const indexResult = serializeType(indexType, checker, visited, depth + 1);
+            // JSON Schema uses additionalProperties for index signatures
+            if (indexResult.schema.type !== 'any' || indexResult.schema.properties) {
+              // Only set if it's a meaningful type (not just 'any' fallback)
+              if (!isFallbackAnySchema(indexResult.schema, indexType, checker)) {
+                properties['[key: string]'] = indexResult.schema;
+              }
+            }
+          }
+        } catch (error) {
+          // Index signature extraction failed, continue without it
+          console.warn(`Warning: Could not extract index signature`, error);
         }
       }
 
@@ -645,13 +979,178 @@ function serializeType(
     }
   }
 
-  // Fallback
+  // Fallback - check type flags to determine if it's a valid JSON Schema type
+  // Valid JSON Schema types: string, number, integer, boolean, object, array, null
+  
+  // Check if it's an enum type (TypeScript enum)
+  if (type.flags & ts.TypeFlags.Enum) {
+    try {
+      const symbol = type.getSymbol();
+      if (symbol) {
+        const enumMembers = checker.getPropertiesOfType(type);
+        if (enumMembers.length > 0) {
+          // Extract enum values - enum members are typically string or number literals
+          const values: (string | number)[] = [];
+          for (const member of enumMembers) {
+            const memberDeclaration = member.valueDeclaration || member.declarations?.[0];
+            if (memberDeclaration) {
+              const memberType = checker.getTypeOfSymbolAtLocation(member, memberDeclaration);
+              const strValue = getStringLiteralValue(memberType);
+              if (strValue !== null) {
+                values.push(strValue);
+              } else {
+                const numValue = getNumberLiteralValue(memberType);
+                if (numValue !== null) {
+                  values.push(numValue);
+                }
+              }
+            }
+          }
+          if (values.length > 0) {
+            // Check if all values are strings or all are numbers
+            const allStrings = values.every(v => typeof v === 'string');
+            const allNumbers = values.every(v => typeof v === 'number');
+            if (allStrings) {
+              return { isOptional: false, schema: { type: 'string', enum: values.filter((v): v is string => typeof v === 'string') } };
+            } else if (allNumbers) {
+              const numberValues = values.filter((v): v is number => typeof v === 'number');
+              return { isOptional: false, schema: { type: 'number', enum: numberValues } };
+            }
+          }
+        }
+      }
+    } catch (error) {
+      console.warn(`Warning: Could not extract enum values for type: ${typeString}`, error);
+    }
+    // If we can't extract enum values, use 'any'
+    return { isOptional: false, schema: { type: 'any' } };
+  }
+  
+  // Check if it's a type reference (like InternalFilterType.StringFilter)
+  // Type references that aren't objects/arrays/primitives should use 'any'
+  if (type.flags & ts.TypeFlags.Object) {
+    // Already handled above, but check if it's an empty object type
+    const props = checker.getPropertiesOfType(type);
+    if (props.length === 0) {
+      // Empty object or type reference we can't resolve
+      // Check if typeString suggests it's a named type reference
+      if (typeString && typeString.includes('.')) {
+        return { isOptional: false, schema: { type: 'any' } };
+      }
+    }
+  }
+  
+  // Check if typeString is a valid JSON Schema primitive type
+  const lowerTypeString = typeString?.toLowerCase();
+  
+  // If it's a valid JSON Schema type, use it (shouldn't happen here, but safety check)
+  if (lowerTypeString && VALID_JSON_SCHEMA_TYPES.has(lowerTypeString)) {
+    // Type assertion is safe here because VALID_JSON_SCHEMA_TYPES validates the value
+    const validType = lowerTypeString as 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+    return {
+      isOptional: false,
+      schema: { type: validType }
+    };
+  }
+  
+  // Try to resolve type references before giving up
+  const resolvedType = resolveTypeReference(type, checker);
+  if (resolvedType) {
+    try {
+      const resolvedResult = serializeType(resolvedType, checker, visited, depth + 1);
+      if (!isFallbackAnySchema(resolvedResult.schema, resolvedType, checker)) {
+        return resolvedResult;
+      }
+    } catch (error) {
+      // Resolution failed, continue to fallback
+    }
+  }
+
+  // Handle special type flags
+  if (type.flags & ts.TypeFlags.Never) {
+    return { isOptional: false, schema: { type: 'null' } };
+  }
+  if (type.flags & ts.TypeFlags.Unknown) {
+    return { isOptional: false, schema: { type: 'any' } };
+  }
+  if (type.flags & ts.TypeFlags.Any) {
+    return { isOptional: false, schema: { type: 'any' } };
+  }
+
+  // For any other unrecognized type, use 'any' instead of invalid type strings
+  // This prevents errors like "type": "InternalFilterType.StringFilter"
   return {
     isOptional: false,
-    schema: { type: typeString.length < 100 ? typeString : 'any' }
+    schema: { type: 'any' }
   };
 }
 
+/**
+ * Extract default value from an expression
+ * Evaluates simple literals instead of using getText()
+ */
+function extractDefaultValue(
+  initializer: ts.Expression,
+  checker: ts.TypeChecker
+): any {
+  // Handle string literals
+  if (ts.isStringLiteral(initializer)) {
+    return initializer.text;
+  }
+  
+  // Handle numeric literals
+  if (ts.isNumericLiteral(initializer)) {
+    return Number(initializer.text);
+  }
+  
+  // Handle boolean literals
+  if (initializer.kind === ts.SyntaxKind.TrueKeyword) {
+    return true;
+  }
+  if (initializer.kind === ts.SyntaxKind.FalseKeyword) {
+    return false;
+  }
+  
+  // Handle null
+  if (initializer.kind === ts.SyntaxKind.NullKeyword) {
+    return null;
+  }
+  
+  // Handle array literals - serialize as JSON string
+  if (ts.isArrayLiteralExpression(initializer)) {
+    try {
+      const elements = initializer.elements
+        .map(el => extractDefaultValue(el, checker))
+        .filter(v => v !== undefined);
+      return JSON.stringify(elements);
+    } catch {
+      return undefined;
+    }
+  }
+  
+  // Handle object literals - serialize as JSON string
+  if (ts.isObjectLiteralExpression(initializer)) {
+    try {
+      const obj: Record<string, any> = {};
+      for (const prop of initializer.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+          const key = prop.name.text;
+          const value = extractDefaultValue(prop.initializer, checker);
+          if (value !== undefined) {
+            obj[key] = value;
+          }
+        }
+      }
+      return JSON.stringify(obj);
+    } catch {
+      return undefined;
+    }
+  }
+  
+  // For complex expressions, return undefined (don't include default)
+  return undefined;
+}
+
 /**
  * Extract metadata from a function
  */
@@ -739,6 +1238,20 @@ function extractFunctionMetadata(
       ? functionNode.parameters
       : [];
 
+  // Extract generic type parameters and their constraints
+  const genericConstraints = new Map<string, ts.Type>();
+  if (ts.isFunctionDeclaration(node) && node.typeParameters) {
+    for (const typeParam of node.typeParameters) {
+      if (ts.isIdentifier(typeParam.name)) {
+        const paramName = typeParam.name.text;
+        if (typeParam.constraint) {
+          const constraintType = checker.getTypeFromTypeNode(typeParam.constraint);
+          genericConstraints.set(paramName, constraintType);
+        }
+      }
+    }
+  }
+
   for (const param of parameters) {
     const paramName = param.name.getText(sourceFile);
     const hasDefault = param.initializer !== undefined;
@@ -747,7 +1260,21 @@ function extractFunctionMetadata(
     let isOptional = false;
 
     if (param.type) {
-      const type = checker.getTypeFromTypeNode(param.type);
+      // Try to get type from type annotation
+      let type = checker.getTypeFromTypeNode(param.type);
+      
+      // If it's a generic type parameter, try to use its constraint
+      if (type.flags & ts.TypeFlags.TypeParameter) {
+        const symbol = type.getSymbol();
+        if (symbol) {
+          const typeParamName = symbol.getName();
+          const constraint = genericConstraints.get(typeParamName);
+          if (constraint) {
+            type = constraint;
+          }
+        }
+      }
+      
       const result = serializeType(type, checker);
       propSchema = result.schema;
       isOptional = result.isOptional;
@@ -761,9 +1288,23 @@ function extractFunctionMetadata(
       isOptional = true;
     }
 
-    // Add default value if present
-    if (hasDefault) {
-      propSchema.default = param.initializer!.getText(sourceFile);
+    // Add default value if present - use proper extraction instead of getText()
+    if (hasDefault && param.initializer) {
+      const defaultValue = extractDefaultValue(param.initializer, checker);
+      if (defaultValue !== undefined) {
+        // JSON Schema supports string, number, boolean, and null for default values
+        // The interface allows any via index signature, so we can assign directly
+        if (typeof defaultValue === 'string') {
+          propSchema.default = defaultValue;
+        } else if (typeof defaultValue === 'number' || typeof defaultValue === 'boolean' || defaultValue === null) {
+          // JSON Schema allows these types for default, but TypeScript interface only declares string
+          // Use type assertion to the index signature type which allows any
+          (propSchema as any).default = defaultValue;
+        } else {
+          // For complex values (arrays/objects), store as JSON string
+          propSchema.default = String(defaultValue);
+        }
+      }
     }
 
     // Add description from JSDoc