@pikku/cli 0.12.0 → 0.12.1

package/dist/src/functions/wirings/triggers/serialize-trigger-meta.js

@@ -6,7 +6,7 @@ export const serializeTriggerMetaTS = (triggerMeta, jsonImportPath, supportsImpo
         ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
         : `import metaData from '${jsonImportPath}'`;
     const serializedOutput = [];
-    serializedOutput.push("import { pikkuState } from '@pikku/core'");
+    serializedOutput.push("import { pikkuState } from '@pikku/core/internal'");
     serializedOutput.push("import { TriggerMeta } from '@pikku/core/trigger'");
     serializedOutput.push(importStatement);
     serializedOutput.push('');
@@ -26,7 +26,7 @@ export const serializeTriggerSourceMetaTS = (sourceMeta, jsonImportPath, support
         ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
         : `import metaData from '${jsonImportPath}'`;
     const serializedOutput = [];
-    serializedOutput.push("import { pikkuState } from '@pikku/core'");
+    serializedOutput.push("import { pikkuState } from '@pikku/core/internal'");
     serializedOutput.push("import { TriggerSourceMeta } from '@pikku/core/trigger'");
     serializedOutput.push(importStatement);
     serializedOutput.push('');

package/dist/src/functions/wirings/variables/serialize-variables-types.d.ts

@@ -1,5 +1,5 @@
-import { VariableDefinitions } from '@pikku/core/variable';
-import { SchemaRef } from '@pikku/inspector';
+import type { VariableDefinitions } from '@pikku/core/variable';
+import type { SchemaRef } from '@pikku/inspector';
 export interface SerializeVariablesOptions {
     definitions: VariableDefinitions;
     schemaLookup: Map<string, SchemaRef>;

package/dist/src/functions/wirings/workflow/pikku-command-workflow.js

@@ -37,10 +37,10 @@ export const pikkuWorkflow = pikkuSessionlessFunc({
             }
         }
         if (workflowsWiringMetaFile && workflowMetaDir) {
-            await writeFileInDir(logger, workflowsWiringMetaFile, serializeWorkflowMeta(workflowsWiringMetaFile, workflowMetaDir, allWorkflowNames, packageMappings, schema?.supportsImportAttributes ?? false, config.externalPackageName));
+            await writeFileInDir(logger, workflowsWiringMetaFile, serializeWorkflowMeta(workflowsWiringMetaFile, workflowMetaDir, allWorkflowNames, packageMappings, schema?.supportsImportAttributes ?? false, config.addonName));
         }
         const metaImportPath = getFileImportRelativePath(workflowsWiringFile, workflowsWiringMetaFile, packageMappings);
-        await writeFileInDir(logger, workflowsWiringFile, serializeWorkflowRegistration(workflowsWiringFile, metaImportPath, allWorkflowNames, workflows.files, workflows.graphFiles, packageMappings, config.externalPackageName));
+        await writeFileInDir(logger, workflowsWiringFile, serializeWorkflowRegistration(workflowsWiringFile, metaImportPath, allWorkflowNames, workflows.files, workflows.graphFiles, packageMappings, config.addonName));
         const functionTypesImportPath = getFileImportRelativePath(workflowTypesFile, functionTypesFile, packageMappings);
         const rpcMapImportPath = getFileImportRelativePath(workflowTypesFile, config.rpcInternalMapDeclarationFile, packageMappings);
         const workflowMapImportPath = getFileImportRelativePath(workflowTypesFile, workflowMapDeclarationFile, packageMappings);

package/dist/src/functions/wirings/workflow/serialize-workflow-map.d.ts

@@ -4,6 +4,6 @@
 import type { WorkflowsMeta } from '@pikku/core/workflow';
 import { type TypesMap } from '@pikku/inspector';
 import type { SerializedWorkflowGraphs } from '@pikku/inspector/workflow-graph';
-import { FunctionsMeta } from '@pikku/core';
-import { Logger } from '@pikku/core/services';
+import type { FunctionsMeta } from '@pikku/core';
+import type { Logger } from '@pikku/core/services';
 export declare const serializeWorkflowMap: (logger: Logger, relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, workflowsMeta: WorkflowsMeta, graphMeta: SerializedWorkflowGraphs) => string;

package/dist/src/functions/wirings/workflow/serialize-workflow-meta.js

@@ -7,7 +7,7 @@ import { sanitizeTypeName } from '@pikku/inspector';
 export const serializeWorkflowMeta = (outputPath, metaDir, workflowNames, packageMappings, supportsImportAttributes, packageName) => {
     const pkg = packageName ? `'${packageName}'` : 'null';
     if (workflowNames.length === 0) {
-        return `import { pikkuState } from '@pikku/core'
+        return `import { pikkuState } from '@pikku/core/internal'
 import type { SerializedWorkflowGraphs } from '@pikku/inspector/workflow-graph'
 
 const workflowsMeta: SerializedWorkflowGraphs = {}
@@ -31,7 +31,7 @@ pikkuState(${pkg}, 'workflows', 'meta', workflowsMeta)`;
         return `  '${name}': ${sanitizedIdentifier}Meta,`;
     })
         .join('\n');
-    return `import { pikkuState } from '@pikku/core'
+    return `import { pikkuState } from '@pikku/core/internal'
 import type { SerializedWorkflowGraphs } from '@pikku/inspector/workflow-graph'
 
 ${imports}

package/dist/src/services/cli-logger-forwarder.service.d.ts

@@ -1,6 +1,7 @@
-import { Logger, LogLevel } from '@pikku/core/services';
-import { PikkuChannel } from '@pikku/core/channel';
-import { ErrorCode } from '@pikku/inspector';
+import type { Logger } from '@pikku/core/services';
+import { LogLevel } from '@pikku/core/services';
+import type { PikkuChannel } from '@pikku/core/channel';
+import type { ErrorCode } from '@pikku/inspector';
 /**
  * Log message structure sent through the channel
  */

package/dist/src/services/cli-logger.service.d.ts

@@ -1,5 +1,6 @@
-import { Logger, LogLevel } from '@pikku/core/services';
-import { ErrorCode } from '@pikku/inspector';
+import type { Logger } from '@pikku/core/services';
+import { LogLevel } from '@pikku/core/services';
+import type { ErrorCode } from '@pikku/inspector';
 export declare class CLILogger implements Logger {
     private silent;
     private level;

package/dist/src/services.d.ts

@@ -1,7 +1,8 @@
 import type { Config, Services, SingletonServices, UserSession } from '../types/application-types.js';
-import { CreateConfig, CreateWireServices, CreateSingletonServices } from '@pikku/core';
-import { PikkuCLIConfig } from '../types/config.js';
-import { ForwardedLogMessage } from './services/cli-logger-forwarder.service.js';
+import type { CreateConfig } from '@pikku/core';
+import type { CreateWireServices, CreateSingletonServices } from '@pikku/core/internal';
+import type { PikkuCLIConfig } from '../types/config.js';
+import type { ForwardedLogMessage } from './services/cli-logger-forwarder.service.js';
 /**
  * Default CLI renderer that logs output using the logger
  */

package/dist/src/services.js

@@ -5,7 +5,7 @@ import { getPikkuCLIConfig } from './utils/pikku-cli-config.js';
 import { inspect, serializeInspectorState, deserializeInspectorState, filterInspectorState, getInitialInspectorState, ErrorCode, } from '@pikku/inspector';
 import { glob } from 'tinyglobby';
 import path from 'path';
-import { CLILoggerForwarder, } from './services/cli-logger-forwarder.service.js';
+import { CLILoggerForwarder } from './services/cli-logger-forwarder.service.js';
 import { readFile, writeFile } from 'fs/promises';
 import { loadManifest } from './utils/contract-versions.js';
 import { join } from 'path';
@@ -209,7 +209,7 @@ export const createSingletonServices = async (config) => {
             unfilteredState = await inspect(logger, wiringFiles, {
                 setupOnly,
                 rootDir,
-                isExternalPackage: config.externalPackage,
+                isAddon: config.addon,
                 types: {
                     configFileType: config.configFile,
                     userSessionType: config.userSessionType,
@@ -217,7 +217,6 @@ export const createSingletonServices = async (config) => {
                     wireServicesFactoryType: config.wireServicesFactoryType,
                 },
                 tags: config.tags,
-                externalPackages: config.externalPackages,
                 schemaConfig: !setupOnly
                     ? {
                         tsconfig: config.tsconfig,

package/dist/src/utils/check-required-types.d.ts

@@ -1,4 +1,4 @@
-import { FilesAndMethodsErrors } from '@pikku/inspector';
+import type { FilesAndMethodsErrors } from '@pikku/inspector';
 export type RequiredTypes = Partial<{
     config: boolean;
     wireServiceType: boolean;

package/dist/src/utils/contract-versions.d.ts

@@ -1,6 +1,6 @@
 import type { VersionManifest } from '@pikku/inspector';
 import { createEmptyManifest } from '@pikku/inspector';
 export { createEmptyManifest };
-export type { ContractEntry, VersionValidateError, VersionManifest, VersionManifestEntry, } from '@pikku/inspector';
+export type { ContractEntry, VersionHashEntry, VersionValidateError, VersionManifest, VersionManifestEntry, } from '@pikku/inspector';
 export declare function loadManifest(manifestPath: string): Promise<VersionManifest | null>;
 export declare function saveManifest(manifestPath: string, manifest: VersionManifest): Promise<void>;

package/dist/src/utils/file-writer.d.ts

@@ -1,9 +1,14 @@
-import { CLILogger } from '../services/cli-logger.service.js';
+import type { CLILogger } from '../services/cli-logger.service.js';
 export declare const DO_NOT_MODIFY_COMMENT: string;
 export declare const writeFileInDir: (logger: CLILogger, path: string, content: string, { ignoreModifyComment, logWrite, }?: {
     ignoreModifyComment?: boolean;
     logWrite?: boolean;
 }) => Promise<void>;
+export declare function kebabCase(str: string): string;
+export declare function scaffoldFilePath(config: {
+    rootDir: string;
+    srcDirectories: string[];
+}, subdir: string, name: string, suffix: string, overrideDir?: string): string;
 export declare const removeFileInDir: (logger: CLILogger, path: string, { logRemove }?: {
     logRemove?: boolean;
 }) => Promise<void>;

package/dist/src/utils/file-writer.js

@@ -1,4 +1,4 @@
-import { dirname } from 'path';
+import { dirname, join } from 'path';
 import { mkdir, readFile, writeFile, rm } from 'fs/promises';
 import { existsSync } from 'fs';
 import { getCLIVersion } from './get-cli-version.js';
@@ -39,6 +39,19 @@ export const writeFileInDir = async (logger, path, content, { ignoreModifyCommen
         }
     }
 };
+export function kebabCase(str) {
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+        .toLowerCase();
+}
+export function scaffoldFilePath(config, subdir, name, suffix, overrideDir) {
+    const fileName = kebabCase(name);
+    if (overrideDir) {
+        return join(overrideDir, subdir, `${fileName}${suffix}`);
+    }
+    return join(config.rootDir, config.srcDirectories[0], subdir, `${fileName}${suffix}`);
+}
 export const removeFileInDir = async (logger, path, { logRemove = true } = {}) => {
     // Check if file exists before attempting removal
     if (existsSync(path)) {

package/dist/src/utils/generate-bootstrap-file.d.ts

@@ -1,3 +1,3 @@
-import { Config } from '../../types/application-types.js';
-import { CLILogger } from '../services/cli-logger.service.js';
+import type { Config } from '../../types/application-types.js';
+import type { CLILogger } from '../services/cli-logger.service.js';
 export declare const generateBootstrapFile: (logger: CLILogger, config: Config, bootstrapFile: string, specificImports: string[], schemas?: boolean, hasMiddleware?: boolean) => Promise<void>;

package/dist/src/utils/openapi/codegen.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Generates addon files from a parsed OpenAPI spec.
+ * Returns Record<string, string> compatible with getAddonFiles output.
+ */
+import type { ParsedSpec } from './parse-openapi.js';
+interface AddonVars {
+    name: string;
+    camelName: string;
+    pascalName: string;
+    screamingName: string;
+    displayName: string;
+    description: string;
+}
+interface CodegenFlags {
+    oauth: boolean;
+    secret: boolean;
+}
+export declare function generateAddonFromOpenAPI(spec: ParsedSpec, vars: AddonVars, flags: CodegenFlags): Record<string, string>;
+export {};

package/dist/src/utils/openapi/codegen.js

@@ -0,0 +1,288 @@
+import { schemaToZod, schemaVarName, createContext, } from './zod-codegen.js';
+import { generateOperationNames, detectCommonPrefix, } from './naming.js';
+const GENERIC_SUMMARIES = new Set([
+    'index', 'show', 'create', 'update', 'destroy', 'delete', 'list',
+]);
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function humanDescription(named, parsed) {
+    if (parsed.responseDescription) {
+        return capitalize(parsed.responseDescription);
+    }
+    const summary = parsed.summary?.trim();
+    if (summary && !GENERIC_SUMMARIES.has(summary.toLowerCase())) {
+        return capitalize(summary);
+    }
+    if (parsed.description && !GENERIC_SUMMARIES.has(parsed.description.trim().toLowerCase())) {
+        return capitalize(parsed.description.trim());
+    }
+    const words = named.functionName
+        .replace(/([A-Z])/g, ' $1')
+        .trim()
+        .toLowerCase();
+    return capitalize(words);
+}
+export function generateAddonFromOpenAPI(spec, vars, flags) {
+    const files = {};
+    const { name } = vars;
+    // Build context for Zod codegen with component schema refs
+    const schemaRefs = new Map();
+    for (const schemaName of Object.keys(spec.componentSchemas)) {
+        schemaRefs.set(schemaName, schemaVarName(schemaName));
+    }
+    const ctx = createContext(schemaRefs);
+    // Generate operation names
+    const paths = spec.operations.map((op) => op.path);
+    const commonPrefix = detectCommonPrefix(paths);
+    const namedOps = generateOperationNames(spec.operations.map((op) => ({
+        method: op.method,
+        path: op.path,
+        operationId: op.operationId,
+    })), commonPrefix);
+    // Pair named operations with their parsed data
+    const opPairs = namedOps.map((named, i) => ({ named, parsed: spec.operations[i] }));
+    // Generate types file with shared schemas (only if there are any)
+    if (Object.keys(spec.componentSchemas).length > 0) {
+        files[`src/${name}.types.ts`] = generateTypesFile(spec, ctx);
+    }
+    // Generate function files
+    const functionExports = [];
+    for (const { named, parsed } of opPairs) {
+        const funcCtx = createContext(schemaRefs);
+        const funcCode = generateFunctionFile(named, parsed, vars, funcCtx);
+        files[`src/functions/${named.functionName}.function.ts`] = funcCode;
+        functionExports.push(named.functionName);
+    }
+    // Generate index.ts with all exports
+    files['src/index.ts'] = generateIndexFile(functionExports);
+    // Generate typed API service class with route map
+    files[`src/${name}-api.service.ts`] = generateServiceFile(spec, opPairs, vars, flags);
+    return files;
+}
+function generateTypesFile(spec, ctx) {
+    const lines = [];
+    lines.push("import { z } from 'zod'");
+    lines.push('');
+    lines.push(`// Shared schemas from ${spec.info.title} v${spec.info.version}`);
+    lines.push('');
+    for (const [name, schema] of Object.entries(spec.componentSchemas)) {
+        const varName = schemaVarName(name);
+        const zodCode = schemaToZod(schema, ctx);
+        lines.push(`export const ${varName} = ${zodCode}`);
+        lines.push(`export type ${name} = z.infer<typeof ${varName}>`);
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+function generateFunctionFile(named, parsed, vars, ctx) {
+    const lines = [];
+    const { camelName } = vars;
+    const hasInput = parsed.pathParams.length > 0 ||
+        parsed.queryParams.length > 0 ||
+        parsed.requestBody;
+    const pascalName = named.functionName.charAt(0).toUpperCase() + named.functionName.slice(1);
+    const inputName = `${pascalName}Input`;
+    const outputName = `${pascalName}Output`;
+    lines.push("import { z } from 'zod'");
+    lines.push("import { pikkuSessionlessFunc } from '#pikku'");
+    lines.push('');
+    // Build Input schema (exported for pikku schema discovery)
+    if (hasInput) {
+        const inputCode = buildInputSchema(parsed, ctx);
+        lines.push(`export const ${inputName} = ${inputCode}`);
+        lines.push('');
+    }
+    // Build Output schema (exported for pikku schema discovery)
+    if (parsed.responseSchema) {
+        const outputCode = schemaToZod(parsed.responseSchema, ctx);
+        lines.push(`export const ${outputName} = ${outputCode}`);
+        lines.push('');
+    }
+    const description = humanDescription(named, parsed);
+    const method = parsed.method.toUpperCase();
+    const funcConfig = [];
+    funcConfig.push(`  description: ${JSON.stringify(description)},`);
+    if (hasInput)
+        funcConfig.push(`  input: ${inputName},`);
+    if (parsed.responseSchema)
+        funcConfig.push(`  output: ${outputName},`);
+    const funcParams = hasInput
+        ? `{ ${camelName} }, data`
+        : `{ ${camelName} }`;
+    const returnCast = parsed.responseSchema ? ' as any' : '';
+    funcConfig.push(`  func: async (${funcParams}) => {`, `    return ${camelName}.call('${method}', '${parsed.path}'${hasInput ? ', data' : ''})${returnCast}`, '  },');
+    lines.push(`export const ${named.functionName} = pikkuSessionlessFunc({`);
+    lines.push(funcConfig.join('\n'));
+    lines.push('})');
+    lines.push('');
+    return lines.join('\n');
+}
+function buildInputSchema(parsed, ctx) {
+    const props = [];
+    for (const param of parsed.pathParams) {
+        const zodCode = schemaToZod(param.schema, ctx, { optional: !param.required });
+        const desc = param.description
+            ? `${zodCode}.describe(${JSON.stringify(param.description)})`
+            : zodCode;
+        props.push(`  ${param.name}: ${desc},`);
+    }
+    for (const param of parsed.queryParams) {
+        const zodCode = schemaToZod(param.schema, ctx, { optional: !param.required });
+        const desc = param.description
+            ? `${zodCode}.describe(${JSON.stringify(param.description)})`
+            : zodCode;
+        props.push(`  ${param.name}: ${desc},`);
+    }
+    if (parsed.requestBody) {
+        if (parsed.requestBody.properties) {
+            const requiredSet = new Set(parsed.requestBody.required ?? []);
+            for (const [key, propSchema] of Object.entries(parsed.requestBody.properties)) {
+                const isOptional = !requiredSet.has(key);
+                const zodCode = schemaToZod(propSchema, ctx, { optional: isOptional });
+                props.push(`  ${key}: ${zodCode},`);
+            }
+        }
+        else {
+            const bodyZod = schemaToZod(parsed.requestBody, ctx);
+            props.push(`  body: ${bodyZod},`);
+        }
+    }
+    return `z.object({\n${props.join('\n')}\n})`;
+}
+function generateIndexFile(functionExports) {
+    const lines = [];
+    for (const name of functionExports) {
+        lines.push(`export { ${name} } from './functions/${name}.function.js'`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+function generateServiceFile(spec, opPairs, vars, flags) {
+    const { name, pascalName, screamingName, displayName } = vars;
+    const lines = [];
+    const baseUrl = spec.baseUrl || 'https://api.example.com';
+    if (flags.oauth) {
+        lines.push("import { OAuth2Client } from '@pikku/core/oauth2'");
+        lines.push("import type { TypedSecretService } from '#pikku/secrets/pikku-secrets.gen.js'");
+    }
+    else if (flags.secret) {
+        lines.push(`import type { ${pascalName}Secrets } from './${name}.secret.js'`);
+    }
+    lines.push('');
+    lines.push(`const BASE_URL = ${JSON.stringify(baseUrl)}`);
+    lines.push('');
+    if (flags.oauth) {
+        lines.push(`export const ${screamingName}_OAUTH2_CONFIG = {`);
+        lines.push(`  tokenSecretId: '${screamingName}_TOKENS',`);
+        lines.push(`  authorizationUrl: 'https://example.com/oauth2/authorize',`);
+        lines.push(`  tokenUrl: 'https://example.com/oauth2/token',`);
+        lines.push("  scopes: ['read', 'write'],");
+        lines.push('}');
+        lines.push('');
+    }
+    // Generate route map from parsed operations
+    const routes = {};
+    for (const { parsed } of opPairs) {
+        const key = `${parsed.method.toUpperCase()} ${parsed.path}`;
+        routes[key] = {
+            path: parsed.pathParams.map((p) => p.name),
+            query: parsed.queryParams.map((p) => p.name),
+        };
+    }
+    lines.push(`const ROUTES: Record<string, { path: string[], query: string[] }> = ${JSON.stringify(routes, null, 2)}`);
+    lines.push('');
+    // Class declaration
+    lines.push(`export class ${pascalName}Service {`);
+    if (flags.oauth) {
+        lines.push('  private oauth: OAuth2Client');
+        lines.push('');
+        lines.push(`  constructor(secrets: TypedSecretService) {`);
+        lines.push('    this.oauth = new OAuth2Client(');
+        lines.push(`      ${screamingName}_OAUTH2_CONFIG,`);
+        lines.push(`      '${screamingName}_APP_CREDENTIALS',`);
+        lines.push('      secrets');
+        lines.push('    )');
+        lines.push('  }');
+    }
+    else if (flags.secret) {
+        lines.push(`  constructor(private creds: ${pascalName}Secrets) {}`);
+    }
+    lines.push('');
+    // call() method — splits data into path/query/body using route map
+    lines.push('  async call<T>(');
+    lines.push("    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH',");
+    lines.push('    path: string,');
+    lines.push('    data?: Record<string, unknown>');
+    lines.push('  ): Promise<T> {');
+    lines.push('    const route = ROUTES[`${method} ${path}`]');
+    lines.push('    let endpoint = path');
+    lines.push('    let body: Record<string, unknown> | undefined');
+    lines.push('    const query: Record<string, string> = {}');
+    lines.push('');
+    lines.push('    if (data && route) {');
+    lines.push('      // Interpolate path params');
+    lines.push('      for (const param of route.path) {');
+    lines.push('        if (data[param] !== undefined) {');
+    lines.push('          endpoint = endpoint.replace(`{${param}}`, String(data[param]))');
+    lines.push('        }');
+    lines.push('      }');
+    lines.push('      // Extract query params');
+    lines.push('      for (const param of route.query) {');
+    lines.push('        if (data[param] !== undefined) {');
+    lines.push('          query[param] = String(data[param])');
+    lines.push('        }');
+    lines.push('      }');
+    lines.push('      // Everything else goes into body');
+    lines.push('      const pathAndQuery = new Set([...route.path, ...route.query])');
+    lines.push('      const remaining = Object.fromEntries(');
+    lines.push('        Object.entries(data).filter(([k]) => !pathAndQuery.has(k))');
+    lines.push('      )');
+    lines.push('      if (Object.keys(remaining).length > 0) {');
+    lines.push('        body = remaining');
+    lines.push('      }');
+    lines.push('    }');
+    lines.push('');
+    lines.push('    const url = new URL(`${BASE_URL}${endpoint}`)');
+    lines.push('    for (const [key, value] of Object.entries(query)) {');
+    lines.push('      url.searchParams.set(key, value)');
+    lines.push('    }');
+    lines.push('');
+    if (flags.oauth) {
+        lines.push('    const response = await this.oauth.request(url.toString(), {');
+        lines.push('      method,');
+        lines.push("      headers: { 'Content-Type': 'application/json' },");
+        lines.push('      body: body ? JSON.stringify(body) : undefined,');
+        lines.push('    })');
+    }
+    else if (flags.secret) {
+        lines.push('    const response = await fetch(url.toString(), {');
+        lines.push('      method,');
+        lines.push('      headers: {');
+        lines.push("        'Content-Type': 'application/json',");
+        lines.push('        Authorization: `Bearer ${this.creds.apiKey}`,');
+        lines.push('      },');
+        lines.push('      body: body ? JSON.stringify(body) : undefined,');
+        lines.push('    })');
+    }
+    else {
+        lines.push('    const response = await fetch(url.toString(), {');
+        lines.push('      method,');
+        lines.push("      headers: { 'Content-Type': 'application/json' },");
+        lines.push('      body: body ? JSON.stringify(body) : undefined,');
+        lines.push('    })');
+    }
+    lines.push('');
+    lines.push('    if (!response.ok) {');
+    lines.push('      const errorText = await response.text()');
+    lines.push(`      throw new Error(\`${displayName} API error (\${response.status}): \${errorText}\`)`);
+    lines.push('    }');
+    lines.push('');
+    lines.push('    const text = await response.text()');
+    lines.push("    if (!text) return {} as T");
+    lines.push('    return JSON.parse(text) as T');
+    lines.push('  }');
+    lines.push('}');
+    lines.push('');
+    return lines.join('\n');
+}

package/dist/src/utils/openapi/naming.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Derives function/method names from HTTP method + path.
+ * Uses operationId when available, otherwise generates from path segments.
+ */
+export declare function singularize(word: string): string;
+export declare function toCamelCase(str: string): string;
+export declare function toPascalCase(str: string): string;
+/**
+ * Strip common API prefix from paths (e.g. /api/v2/).
+ * Uses majority voting — a prefix shared by >75% of paths is stripped,
+ * so a few outlier paths (e.g. /oauth/...) don't break detection.
+ */
+export declare function detectCommonPrefix(paths: string[]): string;
+interface OperationForNaming {
+    method: string;
+    path: string;
+    operationId?: string;
+}
+export interface NamedOperation {
+    method: string;
+    path: string;
+    functionName: string;
+    methodName: string;
+}
+/**
+ * Generate function names for a list of operations.
+ * Handles collision detection and auto-deduplication.
+ */
+export declare function generateOperationNames(operations: OperationForNaming[], commonPrefix: string): NamedOperation[];
+export {};