@arcteninc/core 0.0.67 → 0.0.68

package/package.json

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

package/scripts/cli-extract-types-auto-wrapper.cjs

@@ -106,3 +106,4 @@ async function run() {
 
 run();
 
+

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

@@ -1,25 +1,25 @@
-#!/usr/bin/env node
-/**
- * JavaScript wrapper for the CommonJS wrapper script
- * This file exists to ensure binary resolution works correctly
- * when package managers look for .js files
- * 
- * Works in both Bun and Node.js environments, even when package.json has "type": "module"
- */
-
-import { createRequire } from 'module';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-
-// Get __dirname equivalent for ES modules
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// Create require function that works in ES module context
-const require = createRequire(import.meta.url);
-
-// Load and execute the CommonJS wrapper
-// This works in both Node.js (v12+) and Bun
-const wrapperPath = join(__dirname, 'cli-extract-types-auto-wrapper.cjs');
-require(wrapperPath);
-
+#!/usr/bin/env node
+/**
+ * JavaScript wrapper for the CommonJS wrapper script
+ * This file exists to ensure binary resolution works correctly
+ * when package managers look for .js files
+ * 
+ * Works in both Bun and Node.js environments, even when package.json has "type": "module"
+ */
+
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+// Get __dirname equivalent for ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Create require function that works in ES module context
+const require = createRequire(import.meta.url);
+
+// Load and execute the CommonJS wrapper
+// This works in both Node.js (v12+) and Bun
+const wrapperPath = join(__dirname, 'cli-extract-types-auto-wrapper.cjs');
+require(wrapperPath);
+

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

@@ -843,6 +843,75 @@ function serializeTypeCustom(
     }
   }
 
+  // Handle Partial<T> utility type
+  // Check if this is a type reference (like Partial<Settings>)
+  // TypeScript represents Partial<T> as a TypeReference with typeArguments
+  if (type.flags & ts.TypeFlags.Object) {
+    const typeRef = type as ts.TypeReference;
+    if (typeRef.typeArguments && typeRef.typeArguments.length > 0) {
+      const typeSymbol = type.getSymbol();
+      const aliasSymbol = (type as any).getAliasSymbol ? (type as any).getAliasSymbol(checker) : null;
+      
+      // Check symbol name or alias symbol name
+      const typeName = typeSymbol?.getName() || aliasSymbol?.getName();
+      
+      // Also check type string as fallback (e.g., "Partial<Settings>")
+      const typeString = checker.typeToString(type);
+      
+      // Check if it's Partial utility type
+      if (typeName === 'Partial' || typeString.startsWith('Partial<')) {
+        // Extract the type argument (the T in Partial<T>)
+        const baseType = typeRef.typeArguments[0];
+        
+        // Process the base type to get its properties
+        const baseResult = serializeTypeCustom(baseType, checker, defs, visited, depth + 1);
+        
+        // If the base type is an object with properties, make all properties optional
+        if (baseResult.schema.type === 'object' && baseResult.schema.properties) {
+          return {
+            isOptional: false,
+            schema: {
+              type: 'object',
+              properties: baseResult.schema.properties,
+              // Don't include 'required' - all properties are optional in Partial<T>
+            }
+          };
+        }
+        
+        // If base type uses $ref, we need to handle it differently
+        // For Partial<SomeInterface>, we need to make all properties optional
+        if (baseResult.schema.$ref) {
+          // Get the referenced type and process it
+          const refTypeName = baseResult.schema.$ref.replace('#/$defs/', '');
+          if (defs && defs[refTypeName]) {
+            const refSchema = defs[refTypeName];
+            if (refSchema.type === 'object' && refSchema.properties) {
+              // Create a new schema with all properties optional
+              return {
+                isOptional: false,
+                schema: {
+                  type: 'object',
+                  properties: refSchema.properties,
+                  // No required array - all optional
+                }
+              };
+            }
+          }
+        }
+        
+        // Fallback: return the base result but mark as all optional
+        return {
+          isOptional: false,
+          schema: {
+            ...baseResult.schema,
+            // Remove required if present
+            required: undefined,
+          }
+        };
+      }
+    }
+  }
+
   // Handle arrays
   if (checker.isArrayType(type)) {
     const typeArgs = (type as ts.TypeReference).typeArguments;
@@ -984,6 +1053,73 @@ async function serializeType(
     return { isOptional: false, schema: { type: 'number', const: literalType.value } };
   }
 
+  // Handle Partial<T> utility type - check early before other type processing
+  if (type.flags & ts.TypeFlags.Object) {
+    const typeRef = type as ts.TypeReference;
+    if (typeRef.typeArguments && typeRef.typeArguments.length > 0) {
+      const typeSymbol = type.getSymbol();
+      const aliasSymbol = (type as any).getAliasSymbol ? (type as any).getAliasSymbol(checker) : null;
+      
+      // Check symbol name or alias symbol name
+      const typeName = typeSymbol?.getName() || aliasSymbol?.getName();
+      
+      // Also check type string as fallback (e.g., "Partial<Settings>")
+      const typeString = checker.typeToString(type);
+      
+      // Check if it's Partial utility type
+      if (typeName === 'Partial' || typeString.startsWith('Partial<')) {
+        // Extract the type argument (the T in Partial<T>)
+        const baseType = typeRef.typeArguments[0];
+        
+        // Process the base type to get its properties
+        const baseResult = await serializeType(baseType, checker, program, configPath, defs);
+        
+        // If the base type is an object with properties, make all properties optional
+        if (baseResult.schema.type === 'object' && baseResult.schema.properties) {
+          return {
+            isOptional: false,
+            schema: {
+              type: 'object',
+              properties: baseResult.schema.properties,
+              // Don't include 'required' - all properties are optional in Partial<T>
+            }
+          };
+        }
+        
+        // If base type uses $ref, we need to handle it differently
+        // For Partial<SomeInterface>, we need to make all properties optional
+        if (baseResult.schema.$ref) {
+          // Get the referenced type and process it
+          const refTypeName = baseResult.schema.$ref.replace('#/$defs/', '');
+          if (defs && defs[refTypeName]) {
+            const refSchema = defs[refTypeName];
+            if (refSchema.type === 'object' && refSchema.properties) {
+              // Create a new schema with all properties optional
+              return {
+                isOptional: false,
+                schema: {
+                  type: 'object',
+                  properties: refSchema.properties,
+                  // No required array - all optional
+                }
+              };
+            }
+          }
+        }
+        
+        // Fallback: return the base result but mark as all optional
+        return {
+          isOptional: false,
+          schema: {
+            ...baseResult.schema,
+            // Remove required if present
+            required: undefined,
+          }
+        };
+      }
+    }
+  }
+
   // Handle arrays
   if (checker.isArrayType(type)) {
     const typeArgs = (type as ts.TypeReference).typeArguments;
@@ -1276,6 +1412,11 @@ async function extractFunctionMetadata(
     let isOptional = false;
 
     if (param.type) {
+      // Check if the type node text contains "Partial<" before resolving
+      // This helps us detect Partial<T> even if TypeScript resolves it differently
+      const typeNodeText = param.type.getText(sourceFile);
+      const isPartialType = typeNodeText.startsWith('Partial<') || typeNodeText.includes('Partial<');
+      
       // Try to get type from type annotation
       let type = checker.getTypeFromTypeNode(param.type);
       
@@ -1291,11 +1432,53 @@ 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);
-      propSchema = result.schema;
-      isOptional = result.isOptional;
+      // If we detected Partial<T> from the type node, try to extract the base type
+      if (isPartialType && ts.isTypeReferenceNode(param.type) && param.type.typeArguments && param.type.typeArguments.length > 0) {
+        // Extract the base type (T from Partial<T>)
+        const baseTypeNode = param.type.typeArguments[0];
+        const baseType = checker.getTypeFromTypeNode(baseTypeNode);
+        
+        // Process the base type
+        const baseResult = await serializeType(baseType, checker, program, configPath, defs);
+        
+        // Make all properties optional
+        if (baseResult.schema.type === 'object' && baseResult.schema.properties) {
+          propSchema = {
+            type: 'object',
+            properties: baseResult.schema.properties,
+            // No required array - all properties optional
+          };
+          isOptional = false; // The parameter itself is not optional, but its properties are
+        } else if (baseResult.schema.$ref) {
+          // Handle $ref case
+          const refTypeName = baseResult.schema.$ref.replace('#/$defs/', '');
+          if (defs && defs[refTypeName]) {
+            const refSchema = defs[refTypeName];
+            if (refSchema.type === 'object' && refSchema.properties) {
+              propSchema = {
+                type: 'object',
+                properties: refSchema.properties,
+              };
+              isOptional = false;
+            } else {
+              propSchema = baseResult.schema;
+              isOptional = baseResult.isOptional;
+            }
+          } else {
+            propSchema = baseResult.schema;
+            isOptional = baseResult.isOptional;
+          }
+        } else {
+          propSchema = baseResult.schema;
+          isOptional = baseResult.isOptional;
+        }
+      } else {
+        // 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);
+        propSchema = result.schema;
+        isOptional = result.isOptional;
+      }
     } else {
       propSchema = {}; // Empty schema = any value (JSON Schema draft 2020-12)
     }