@bagelink/sdk 1.2.151 → 1.3.1

package/bin/index.ts

@@ -3,9 +3,10 @@
 import fs from 'node:fs'
 import { join } from 'node:path'
 import { openAPI } from '@bagelink/sdk'
+import { splitClientCode } from './splitClientGen'
 import { formatAndWriteCode, getKwargs, handleAuthCode, runEsLintOnDir } from './utils'
 
-const { bagelinkDir, withAuth, openApiUrl, proc } = getKwargs()
+const { bagelinkDir, withAuth, shouldSplitFiles, openApiUrl, proc } = getKwargs()
 
 export async function loadTypes() {
 	const { types, code } = await openAPI(
@@ -15,6 +16,7 @@ export async function loadTypes() {
 
 	if (!fs.existsSync(bagelinkDir)) fs.mkdirSync(bagelinkDir)
 
+	// Generate monolithic files first
 	const typesPath = join(bagelinkDir, 'types.d.ts')
 	await formatAndWriteCode(typesPath, types)
 
@@ -24,8 +26,26 @@ export async function loadTypes() {
 	const indexPath = join(bagelinkDir, 'index.ts')
 	await formatAndWriteCode(indexPath, `export * from './api'\nexport * from './types.d'`)
 
-	await handleAuthCode(withAuth, bagelinkDir)
+	// Optionally split into organized files
+	if (shouldSplitFiles) {
+		try {
+			await splitClientCode({
+				bagelinkDir,
+				useDirectories: true,
+			})
+			// remove monolithic files if splitting is successful
+			console.log('Cleaning up monolithic temporary files...')
+			fs.rmSync(apiPath, { force: true })
+			fs.rmSync(typesPath, { force: true })
+			fs.rmSync(indexPath, { force: true })
+		} catch (error) {
+			console.error('Error splitting client code:', error)
+			// Continue with monolithic files if splitting fails
+		}
+	}
 
+	await handleAuthCode(withAuth, bagelinkDir)
+	console.log('Attempting to format generated files...')
 	await runEsLintOnDir(bagelinkDir)
 
 	console.log('Client & type files generated successfully!!!')

package/bin/splitClientGen.ts

@@ -0,0 +1,718 @@
+import type { TSESTree } from '@typescript-eslint/typescript-estree'
+import fs from 'node:fs'
+import path from 'node:path'
+import { parse, AST_NODE_TYPES } from '@typescript-eslint/typescript-estree'
+import { formatAndWriteCode } from './utils'
+
+/**
+ * Converts a string to camelCase format (first letter lowercase, rest unchanged)
+ * @param str - The string to convert
+ * @returns The camelCase version of the string
+ */
+function toCamelCase(str: string): string {
+	if (!str) return ''
+	return str.charAt(0).toLowerCase() + str.slice(1)
+}
+
+/**
+ * Configuration for the client code splitter
+ */
+export interface SplitClientOptions {
+	/**
+	 * Directory containing the generated files
+	 */
+	bagelinkDir: string
+
+	/**
+	 * Whether to organize into separate directories
+	 */
+	useDirectories?: boolean
+
+	/**
+	 * Strategy for grouping API and type declarations
+	 * Default is to use the first PascalCase word in the name
+	 */
+	groupingStrategy?: GroupingStrategy
+}
+
+/**
+ * Enhanced type for controlling how files are grouped
+ */
+export interface GroupingStrategy {
+	/**
+	 * Extract the group name from a declaration name
+	 * @param name The name of the type or API function
+	 * @returns The group name to use
+	 */
+	getGroupName: (name: string) => string
+
+	/**
+	 * Get the file name for a group
+	 * @param group The group name
+	 * @param kind Whether this is a 'types' or 'api' file
+	 * @returns The file name to use (without directory path)
+	 */
+	getFileName: (group: string, kind: 'types' | 'api') => string
+}
+
+/**
+ * Default grouping strategy using the first PascalCase word
+ */
+export function createDefaultGroupingStrategy(groupingPattern = /^([A-Z][a-z]+)/): GroupingStrategy {
+	return {
+		getGroupName(name: string): string {
+			const match = name.match(groupingPattern)
+			return match ? match[1] : 'Common'
+		},
+
+		getFileName(group: string, kind: 'types' | 'api'): string {
+			// Use the utility function for consistent camelCase conversion
+			const suffix = kind === 'types' ? 'Types' : 'Api'
+			return `${toCamelCase(group)}${suffix}.ts`
+		}
+	}
+}
+
+/**
+ * Group information for code organization
+ */
+interface GroupInfo {
+	types: Set<string>
+	apis: Set<string>
+	dependencies: Set<string>
+}
+
+/**
+ * Parse TypeScript code with consistent options
+ */
+function parseTypeScript(code: string) {
+	return parse(code, {
+		ecmaVersion: 2020,
+		sourceType: 'module',
+		loc: true,
+		range: true, // Critical: This enables position tracking in the AST
+		tokens: true,
+		comment: true,
+	})
+}
+
+/**
+ * Splits the monolithic client code into organized files and directories
+ */
+export async function splitClientCode(options: SplitClientOptions): Promise<void> {
+	const { bagelinkDir, useDirectories = true, groupingStrategy = createDefaultGroupingStrategy() } = options
+	console.log(`Splitting client code in: ${bagelinkDir}`)
+
+	// Create output directories
+	const typesDir = useDirectories ? path.join(bagelinkDir, 'types') : bagelinkDir
+	const apisDir = useDirectories ? path.join(bagelinkDir, 'api') : bagelinkDir
+
+	if (useDirectories) {
+		if (!fs.existsSync(typesDir)) fs.mkdirSync(typesDir, { recursive: true })
+		if (!fs.existsSync(apisDir)) fs.mkdirSync(apisDir, { recursive: true })
+	}
+
+	// Read the generated files
+	const typesFile = path.join(bagelinkDir, 'types.d.ts')
+	const apiFile = path.join(bagelinkDir, 'api.ts')
+
+	if (!fs.existsSync(typesFile) || !fs.existsSync(apiFile)) {
+		throw new Error('Generated client code files not found. Run the generator first.')
+	}
+
+	const typesContent = fs.readFileSync(typesFile, 'utf-8')
+	const apiContent = fs.readFileSync(apiFile, 'utf-8')
+
+	// Extract commonalities first - imports, utility functions, etc.
+	const { commonCode, axiosInstance } = extractCommonCode(apiContent)
+
+	// Parse and organize types
+	const typeGroups = organizeTypes(typesContent, groupingStrategy)
+
+	// Parse and organize API functions
+	const apiGroups = organizeApiFunctions(apiContent, groupingStrategy)
+
+	// Combine the groups information for dependency tracking
+	const groups = mergeGroupInfo(typeGroups, apiGroups)
+
+	// Write the common code
+	if (useDirectories) {
+		await formatAndWriteCode(
+			path.join(apisDir, 'common.ts'),
+			commonCode
+		)
+
+		// Create proper axios export
+		await formatAndWriteCode(
+			path.join(apisDir, 'axios.ts'),
+			axiosInstance
+		)
+	}
+
+	// Generate and write files for each group
+	for (const [group, info] of Object.entries(groups)) {
+		// Write types file
+		if (info.types.size > 0) {
+			const dependencies = getDependencyImports(info.dependencies, groups, 'types')
+			const typesOutput = generateTypesFile(group, info.types, typesContent, dependencies)
+			const typesFileName = useDirectories
+				? path.join(typesDir, groupingStrategy.getFileName(group, 'types'))
+				: path.join(bagelinkDir, groupingStrategy.getFileName(group, 'types'))
+
+			await formatAndWriteCode(typesFileName, typesOutput)
+		}
+
+		// Write API file
+		if (info.apis.size > 0) {
+			const dependencies = getDependencyImports(info.dependencies, groups, 'apis')
+			const apisOutput = generateApiFile(
+				group,
+				info.apis,
+				apiContent,
+				dependencies,
+				useDirectories
+			)
+
+			const apiFileName = path.join(
+				apisDir,
+				groupingStrategy.getFileName(group, 'api')
+			)
+
+			await formatAndWriteCode(apiFileName, apisOutput)
+		}
+	}
+
+	// Create index files
+	if (useDirectories) {
+		// Types index
+		const typesIndexContent = Object.keys(groups)
+			.filter(group => groups[group].types.size > 0)
+			.map(group => `export * from './${toCamelCase(group)}Types';`)
+			.join('\n')
+
+		await formatAndWriteCode(
+			path.join(typesDir, 'index.ts'),
+			typesIndexContent
+		)
+
+		// API index - Export axios only ONCE
+		const apiIndexContent
+			= `export { axios } from './axios';\n${
+				Object.keys(groups)
+					.filter(group => groups[group].apis.size > 0)
+					.map(group => `export * from './${toCamelCase(group)}Api';`)
+					.join('\n')}`
+
+		await formatAndWriteCode(
+			path.join(apisDir, 'index.ts'),
+			apiIndexContent
+		)
+
+		// Root index
+		await formatAndWriteCode(
+			path.join(bagelinkDir, 'index.ts'),
+			`export * from './types';\nexport * from './api';`
+		)
+	} else {
+		// Flat structure - create a single index file
+		const indexContent = Object.keys(groups)
+			.map((group) => {
+				const exports = []
+				if (groups[group].types.size > 0) {
+					exports.push(`export * from './${toCamelCase(group)}Types';`)
+				}
+				if (groups[group].apis.size > 0) {
+					exports.push(`export * from './${toCamelCase(group)}Api';`)
+				}
+				return exports.join('\n')
+			})
+			.join('\n')
+
+		await formatAndWriteCode(
+			path.join(bagelinkDir, 'index.ts'),
+			indexContent
+		)
+	}
+
+	console.log('Client code successfully split into organized files!')
+}
+
+/**
+ * Extracts common code that should be shared across all API files
+ */
+function extractCommonCode(apiContent: string): { commonCode: string, axiosInstance: string } {
+	// Use the consistent parsing function with range tracking
+	const ast = parseTypeScript(apiContent)
+
+	const imports: string[] = []
+	const axiosDefinition: string[] = []
+	const utilityTypes: string[] = []
+
+	for (const node of ast.body) {
+		// Safely access range information with proper null checks
+		if (!node.range) {
+			console.warn(`Node missing range information: ${node.type}`)
+			continue
+		}
+
+		// Get imports
+		if (node.type === 'ImportDeclaration') {
+			imports.push(apiContent.substring(node.range[0], node.range[1]))
+		}
+
+		// Get axios setup
+		if (node.type === 'ExportNamedDeclaration'
+			&& node.declaration?.type === 'VariableDeclaration'
+			&& node.declaration.declarations.some(d => d.id.type === 'Identifier' && d.id.name === 'axios')) {
+			axiosDefinition.push(apiContent.substring(node.range[0], node.range[1]))
+		}
+
+		// Get utility interfaces like UploadOptions
+		if (node.type === 'ExportNamedDeclaration'
+			&& node.declaration?.type === 'TSInterfaceDeclaration') {
+			utilityTypes.push(apiContent.substring(node.range[0], node.range[1]))
+		}
+	}
+
+	const commonCode = [
+		...imports,
+		...utilityTypes
+	].join('\n\n')
+
+	const axiosInstance = [
+		...imports.filter(i => i.includes('axios')),
+		...axiosDefinition
+	].join('\n\n')
+
+	return { commonCode, axiosInstance }
+}
+
+/**
+ * Organizes type definitions into logical groups
+ */
+function organizeTypes(typesContent: string, groupingStrategy: GroupingStrategy): Record<string, GroupInfo> {
+	const ast = parseTypeScript(typesContent)
+	const groups: Record<string, GroupInfo> = {}
+
+	for (const node of ast.body) {
+		// Skip nodes without range info
+		if (!node.range) continue
+
+		if (node.type === 'ExportNamedDeclaration'
+			&& (node.declaration?.type === 'TSTypeAliasDeclaration'
+				|| node.declaration?.type === 'TSInterfaceDeclaration')) {
+			const typeName = node.declaration.id.name
+			const group = groupingStrategy.getGroupName(typeName)
+
+			if (!groups[group]) {
+				groups[group] = {
+					types: new Set(),
+					apis: new Set(),
+					dependencies: new Set()
+				}
+			}
+
+			groups[group].types.add(typeName)
+
+			// Collect dependencies for this type
+			const dependencies = findTypeDependencies(node, typesContent)
+			for (const dep of dependencies) {
+				groups[group].dependencies.add(dep)
+			}
+		}
+	}
+
+	return groups
+}
+
+/**
+ * Organizes API functions into logical groups with enhanced type dependency detection
+ */
+function organizeApiFunctions(apiContent: string, groupingStrategy: GroupingStrategy): Record<string, GroupInfo> {
+	const ast = parseTypeScript(apiContent)
+	const groups: Record<string, GroupInfo> = {}
+
+	// First pass: identify top-level exports
+	for (const node of ast.body) {
+		if (!node.range) continue
+
+		// Handle direct function exports
+		if (node.type === 'ExportNamedDeclaration' && node.declaration?.type === 'VariableDeclaration') {
+			for (const declarator of node.declaration.declarations) {
+				if (declarator.id.type === 'Identifier') {
+					const functionName = declarator.id.name
+
+					// Skip utility exports
+					if (['axios', 'UploadOptions', 'baseURL', 'endpoints', 'schemas'].includes(functionName)) {
+						continue
+					}
+
+					// Check if this is a nested API object (like `auth: {...}` or `dataExports: {...}`)
+					if (declarator.init?.type === 'ObjectExpression') {
+						// For object groups, use the object name as the group name directly
+						// rather than applying the grouping strategy
+						const groupName = functionName
+
+						if (!groups[groupName]) {
+							groups[groupName] = {
+								types: new Set(),
+								apis: new Set(),
+								dependencies: new Set()
+							}
+						}
+
+						groups[groupName].apis.add(functionName)
+
+						// Extract types from the entire object
+						const objectCode = apiContent.substring(node.range[0], node.range[1])
+						const typeRefs = findTypeReferences(objectCode)
+
+						// Add AxiosResponse explicitly as a dependency
+						typeRefs.push('AxiosResponse')
+
+						for (const typeRef of typeRefs) {
+							groups[groupName].dependencies.add(typeRef)
+						}
+
+						continue
+					}
+
+					// Regular function export - use grouping strategy
+					const group = groupingStrategy.getGroupName(functionName)
+
+					if (!groups[group]) {
+						groups[group] = {
+							types: new Set(),
+							apis: new Set(),
+							dependencies: new Set()
+						}
+					}
+
+					groups[group].apis.add(functionName)
+
+					// Find type dependencies in the function
+					const functionCode = apiContent.substring(node.range[0], node.range[1])
+					const typeRefs = findTypeReferences(functionCode)
+
+					for (const typeRef of typeRefs) {
+						groups[group].dependencies.add(typeRef)
+					}
+				}
+			}
+		}
+	}
+
+	return groups
+}
+
+/**
+ * Pre-compiled regex patterns for type reference detection
+ * Defining these outside functions prevents unnecessary recompilation
+ */
+const TYPE_PATTERNS = {
+	// PascalCase type identifiers (handles leading underscores and interface patterns)
+	PASCAL_CASE_TYPE: /(?<!['"$_.])\b_?[A-Z]\w*\b(?!\s*:)/g,
+
+	// Type parameters in generics (e.g., Promise<UserResponse>)
+	GENERIC_TYPE_PARAMS: /<(_?[A-Z]\w*(?:, *_?[A-Z]\w*)*)>/g,
+
+	// Return type annotations including AxiosResponse pattern
+	RETURN_TYPE_ANNOTATION: /\): *Promise<(?:AxiosResponse<)?(_?[A-Z]\w*)(?:\[\])?>+/g,
+
+	// Parameter type annotations
+	PARAM_TYPE_ANNOTATION: /: *(_?[A-Z]\w*)\b/g,
+
+	// Types used in extends, implements, etc.
+	TYPE_RELATION: /(?:extends|implements|keyof|typeof|infer)\s+(_?[A-Z]\w*)/g
+}
+
+/**
+ * Type reference matcher that validates if a string is likely a proper type name
+ */
+const TYPE_NAME_VALIDATOR = /^_?[A-Z]\w*/
+
+/**
+ * Regex for cleaning up type names by removing brackets and other syntax characters
+ */
+const TYPE_CLEANUP_PATTERN = /[<>[\]]/g
+
+/**
+ * Enhanced type reference finder with more robust pattern matching
+ * using pre-compiled regex patterns
+ */
+function findTypeReferences(code: string): string[] {
+	const matches = new Set<string>()
+
+	// Process each pattern with a clean approach to avoid regex stateful issues
+	Object.values(TYPE_PATTERNS).forEach((pattern) => {
+		// Create a fresh copy of the pattern to avoid stateful regex issues
+		const freshPattern = new RegExp(pattern.source, pattern.flags)
+
+		// Use matchAll for cleaner iteration over all matches
+		const allMatches = [...code.matchAll(freshPattern)]
+
+		for (const matchArray of allMatches) {
+			// Get the captured group if it exists, otherwise use the full match
+			const matchValue = matchArray[1] || matchArray[0]
+
+			// Process potential comma-separated type lists (for generics)
+			matchValue.split(',').forEach((type) => {
+				const trimmedType = type.trim().replace(TYPE_CLEANUP_PATTERN, '')
+
+				// Validate it's a proper type name using our validator
+				if (trimmedType && TYPE_NAME_VALIDATOR.test(trimmedType)) {
+					matches.add(trimmedType)
+				}
+			})
+		}
+	})
+
+	// Always include AxiosResponse for API files
+	matches.add('AxiosResponse')
+
+	return [...matches]
+}
+
+/**
+ * Merges type and API group information
+ */
+function mergeGroupInfo(
+	typeGroups: Record<string, GroupInfo>,
+	apiGroups: Record<string, GroupInfo>
+): Record<string, GroupInfo> {
+	const result: Record<string, GroupInfo> = {}
+
+	// Start with all type groups
+	for (const [group, info] of Object.entries(typeGroups)) {
+		result[group] = {
+			types: new Set(info.types),
+			apis: new Set(),
+			dependencies: new Set(info.dependencies)
+		}
+	}
+
+	// Add or merge API groups
+	for (const [group, info] of Object.entries(apiGroups)) {
+		if (!result[group]) {
+			result[group] = {
+				types: new Set(),
+				apis: new Set(info.apis),
+				dependencies: new Set(info.dependencies)
+			}
+		} else {
+			for (const api of info.apis) {
+				result[group].apis.add(api)
+			}
+
+			for (const dep of info.dependencies) {
+				result[group].dependencies.add(dep)
+			}
+		}
+	}
+
+	return result
+}
+
+export type ProgramStatement = ReturnType<typeof parse>['body'][number]
+
+/**
+ * Finds type dependencies in a type declaration
+ */
+function findTypeDependencies(node: ProgramStatement, _typesContent: string): string[] {
+	const dependencies = new Set<string>()
+
+	// Type guard functions for type safety
+	function isTypeReference(node: unknown): node is TSESTree.TSTypeReference {
+		return node !== null && typeof node === 'object' && 'type' in node && node.type === AST_NODE_TYPES.TSTypeReference
+	}
+
+	function isIdentifier(node: unknown): node is TSESTree.Identifier {
+		return node !== null && typeof node === 'object' && 'type' in node && node.type === AST_NODE_TYPES.Identifier
+	}
+
+	// Simple approach - extract all identifiers from type references
+	function visit(node: unknown) {
+		// Handle type references
+		if (isTypeReference(node)) {
+			if ('typeName' in node && isIdentifier(node.typeName)) {
+				dependencies.add(node.typeName.name)
+			}
+		}
+
+		// Recursively visit child nodes
+		if (node && typeof node === 'object') {
+			// Handle arrays
+			if (Array.isArray(node)) {
+				node.forEach((item) => { visit(item) })
+				return
+			}
+
+			// Skip certain properties
+			const skipProps = ['parent', 'range', 'loc']
+
+			// Visit each property
+			Object.entries(node).forEach(([key, value]) => {
+				if (!skipProps.includes(key) && value && typeof value === 'object') {
+					visit(value)
+				}
+			})
+		}
+	}
+
+	visit(node)
+	return Array.from(dependencies)
+}
+
+/**
+ * Generates import statements for dependencies
+ */
+function getDependencyImports(
+	dependencies: Set<string>,
+	groups: Record<string, GroupInfo>,
+	_kind: 'types' | 'apis'
+): Record<string, string[]> {
+	const imports: Record<string, string[]> = {}
+
+	// Find where each dependency is defined
+	for (const dep of dependencies) {
+		for (const [group, info] of Object.entries(groups)) {
+			if (info.types.has(dep)) {
+				if (!imports[group]) {
+					imports[group] = []
+				}
+				imports[group].push(dep)
+				break
+			}
+		}
+	}
+
+	return imports
+}
+
+/**
+ * Generates a types file for a group
+ */
+function generateTypesFile(
+	group: string,
+	typeNames: Set<string>,
+	typesContent: string,
+	dependencies: Record<string, string[]>
+): string {
+	const ast = parseTypeScript(typesContent)
+
+	// Generate imports for dependencies with consistent camelCase
+	const imports = Object.entries(dependencies)
+		.filter(([depGroup]) => depGroup !== group) // Don't import from self
+		.map(([depGroup, types]) => `import type { ${types.sort().join(', ')} } from './${toCamelCase(depGroup)}Types';`
+		)
+
+	// Extract type declarations
+	const declarations: string[] = []
+	for (const node of ast.body) {
+		// Skip nodes without range info
+		if (!node.range) continue
+
+		if (node.type === 'ExportNamedDeclaration'
+			&& (node.declaration?.type === 'TSTypeAliasDeclaration'
+				|| node.declaration?.type === 'TSInterfaceDeclaration')) {
+			const typeName = node.declaration.id.name
+			if (typeNames.has(typeName)) {
+				declarations.push(typesContent.substring(node.range[0], node.range[1]))
+			}
+		}
+	}
+
+	return [
+		...imports,
+		'',
+		...declarations
+	].join('\n')
+}
+
+/**
+ * Generates an API file for a group with improved handling of nested APIs
+ */
+function generateApiFile(
+	_group: string,
+	apiFunctionNames: Set<string>,
+	apiContent: string,
+	dependencies: Record<string, string[]>,
+	useDirectories: boolean
+): string {
+	const ast = parseTypeScript(apiContent)
+
+	// Generate imports
+	const imports = [
+		useDirectories
+			? `import { axios } from './axios';`
+			: `import { axios } from './common';`,
+		`import type { AxiosResponse } from 'axios';`
+	]
+
+	// Add imports for the common utilities
+	if (useDirectories) {
+		imports.push(`import type { UploadOptions } from './common';`)
+	}
+
+	// Add imports for type dependencies with consistent camelCase
+	if (useDirectories) {
+		Object.entries(dependencies).forEach(([depGroup, types]) => {
+			// Filter out AxiosResponse as we're importing it directly
+			const filteredTypes = types.filter(t => t !== 'AxiosResponse')
+			if (filteredTypes.length > 0) {
+				imports.push(`import type { ${filteredTypes.sort().join(', ')} } from '../types/${toCamelCase(depGroup)}Types';`)
+			}
+		})
+	} else {
+		Object.entries(dependencies).forEach(([depGroup, types]) => {
+			// Filter out AxiosResponse as we're importing it directly
+			const filteredTypes = types.filter(t => t !== 'AxiosResponse')
+			if (filteredTypes.length > 0) {
+				imports.push(`import type { ${filteredTypes.sort().join(', ')} } from './${toCamelCase(depGroup)}Types';`)
+			}
+		})
+	}
+
+	// Extract API function declarations with their JSDoc comments
+	const declarations: string[] = []
+
+	for (const node of ast.body) {
+		if (!node.range) continue
+
+		// Handle export declarations
+		if (node.type === 'ExportNamedDeclaration' && node.declaration?.type === 'VariableDeclaration') {
+			for (const declarator of node.declaration.declarations) {
+				if (declarator.id.type === 'Identifier') {
+					const functionName = declarator.id.name
+
+					// Check if this function should be included
+					const shouldInclude = apiFunctionNames.has(functionName)
+
+					if (shouldInclude) {
+						// Get the range of the entire declaration including comments
+						// Find leading comments by using AST comment tokens instead of node properties
+						let startPos = node.range[0]
+						const comments = ast.comments || []
+						const nodeLeadingComments = comments.filter(
+							comment => comment.range[1] <= node.range[0]
+								&& !comments.some(c => comment.range[1] < c.range[1] && c.range[1] <= node.range[0])
+						)
+
+						if (nodeLeadingComments.length > 0) {
+							startPos = nodeLeadingComments[0].range[0]
+						}
+
+						declarations.push(apiContent.substring(startPos, node.range[1]))
+						break
+					}
+				}
+			}
+		}
+	}
+
+	return [
+		...imports.filter(Boolean),
+		'',
+		...declarations
+	].join('\n')
+}

package/bin/utils.ts

@@ -13,6 +13,9 @@ const [_, __, dirFlag, withAuthArg] = proc.argv as Partial<string[]>
 
 const withAuth = withAuthArg === '--auth'
 
+// Parse command line arguments
+const shouldSplitFiles = proc.argv.includes('--split')
+
 if (dirFlag !== undefined) {
 	console.log(`using passed in dir to generate sdk client: ${dirFlag}`)
 } else {
@@ -34,6 +37,7 @@ export function getKwargs() {
 		openApiUrl,
 		bagelinkDir,
 		withAuth,
+		shouldSplitFiles,
 		cwd,
 		env,
 		proc

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bagelink/sdk",
   "type": "module",
-  "version": "1.2.151",
+  "version": "1.3.1",
   "description": "Bagel core sdk packages",
   "author": {
     "name": "Neveh Allon",
@@ -44,12 +44,14 @@
     "dist",
     "src",
     "bin/authClientCode.ts",
+    "bin/splitClientGen.ts",
     "bin/utils.ts"
   ],
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
+    "@typescript-eslint/typescript-estree": "^8.32.0",
     "axios": "^1.9.0"
   },
   "devDependencies": {