@pikku/cli 0.11.2 → 0.12.0

package/dist/src/functions/wirings/mcp/serialize-mcp-json.js

@@ -1,101 +0,0 @@
-import { readFile } from 'fs/promises';
-import { join } from 'path';
-export const serializeMCPJson = async (logger, schemaDirectory, functionsMeta, typesMap, mcpResourceMeta, mcpToolMeta, mcpPromptMeta) => {
-    const tools = [];
-    const resources = [];
-    const prompts = [];
-    // Helper function to load schema from file
-    const loadSchema = async (typeName) => {
-        if (!typeName ||
-            ['boolean', 'string', 'number', 'null', 'undefined', 'void'].includes(typeName)) {
-            return undefined;
-        }
-        const uniqueName = typesMap.getUniqueName(typeName);
-        if (!uniqueName) {
-            return undefined;
-        }
-        try {
-            const schemaPath = join(schemaDirectory, 'schemas', `${uniqueName}.schema.json`);
-            const schemaContent = await readFile(schemaPath, 'utf-8');
-            return JSON.parse(schemaContent);
-        }
-        catch (e) {
-            logger.warn(`Could not load schema for type: ${uniqueName}`);
-            return undefined;
-        }
-    };
-    // Process MCP resources
-    for (const [name, endpointMeta] of Object.entries(mcpResourceMeta)) {
-        const functionMeta = functionsMeta[endpointMeta.pikkuFuncName];
-        if (!functionMeta) {
-            logger.warn(`Function ${endpointMeta.pikkuFuncName} not found in functionsMeta. Skipping resource ${name}.`);
-            continue;
-        }
-        const inputType = functionMeta.inputs?.[0];
-        const outputType = functionMeta.outputs?.[0];
-        const parameters = await loadSchema(inputType);
-        const returns = await loadSchema(outputType);
-        const endpoint = {
-            uri: name,
-            name,
-            description: endpointMeta.description,
-            ...(parameters && { parameters }),
-            ...(returns && { returns }),
-            ...(endpointMeta.streaming && { streaming: true }),
-        };
-        resources.push(endpoint);
-    }
-    // Process MCP tools
-    for (const [name, endpointMeta] of Object.entries(mcpToolMeta)) {
-        const functionMeta = functionsMeta[endpointMeta.pikkuFuncName];
-        if (!functionMeta) {
-            logger.warn(`Function ${endpointMeta.pikkuFuncName} not found in functionsMeta. Skipping tool ${name}.`);
-            continue;
-        }
-        const inputType = functionMeta.inputs?.[0];
-        const outputType = functionMeta.outputs?.[0];
-        const parameters = await loadSchema(inputType);
-        const returns = await loadSchema(outputType);
-        const endpoint = {
-            name,
-            description: endpointMeta.description,
-            ...(parameters && { parameters }),
-            ...(returns && { returns }),
-            ...(endpointMeta.streaming && { streaming: true }),
-        };
-        tools.push(endpoint);
-    }
-    // Process MCP prompts
-    for (const [name, endpointMeta] of Object.entries(mcpPromptMeta)) {
-        const functionMeta = functionsMeta[endpointMeta.pikkuFuncName];
-        if (!functionMeta) {
-            logger.warn(`Function ${endpointMeta.pikkuFuncName} not found in functionsMeta. Skipping prompt ${name}.`);
-            continue;
-        }
-        const inputType = functionMeta.inputs?.[0];
-        // TODO: this needs to be a json schema type, not any
-        const inputSchema = await loadSchema(inputType);
-        // Generate arguments from input schema
-        const argumentsArray = [];
-        if (inputSchema &&
-            typeof inputSchema === 'object' &&
-            inputSchema.properties) {
-            const properties = inputSchema.properties;
-            const required = inputSchema.required || [];
-            for (const [propName, propSchema] of Object.entries(properties)) {
-                argumentsArray.push({
-                    name: propName,
-                    description: propSchema.description || `${propName} parameter`,
-                    required: required.includes(propName),
-                });
-            }
-        }
-        const prompt = {
-            name,
-            description: endpointMeta.description,
-            arguments: argumentsArray,
-        };
-        prompts.push(prompt);
-    }
-    return JSON.stringify({ tools, resources, prompts }, null, 2);
-};

package/dist/src/functions/wirings/middleware/serialize-middleware-groups-meta.d.ts

@@ -1,11 +0,0 @@
-import type { InspectorState } from '@pikku/inspector';
-/**
- * Generates the middleware groups metadata that stores metadata about
- * tag-based and HTTP middleware groups for visualization and inspection.
- *
- * This includes services, middleware count, factory status, etc.
- */
-export declare const serializeMiddlewareGroupsMeta: (state: InspectorState) => {
-    httpGroups: Record<string, any>;
-    tagGroups: Record<string, any>;
-};

package/dist/src/functions/wirings/middleware/serialize-middleware-groups-meta.js

@@ -1,36 +0,0 @@
-/**
- * Generates the middleware groups metadata that stores metadata about
- * tag-based and HTTP middleware groups for visualization and inspection.
- *
- * This includes services, middleware count, factory status, etc.
- */
-export const serializeMiddlewareGroupsMeta = (state) => {
-    // Serialize HTTP middleware groups metadata
-    const httpGroups = {};
-    for (const [pattern, meta] of state.http.routeMiddleware.entries()) {
-        httpGroups[pattern] = {
-            exportName: meta.exportName,
-            sourceFile: meta.sourceFile,
-            position: meta.position,
-            services: meta.services,
-            middlewareCount: meta.middlewareCount,
-            isFactory: meta.isFactory,
-        };
-    }
-    // Serialize tag middleware groups metadata
-    const tagGroups = {};
-    for (const [tag, meta] of state.middleware.tagMiddleware.entries()) {
-        tagGroups[tag] = {
-            exportName: meta.exportName,
-            sourceFile: meta.sourceFile,
-            position: meta.position,
-            services: meta.services,
-            middlewareCount: meta.middlewareCount,
-            isFactory: meta.isFactory,
-        };
-    }
-    return {
-        httpGroups,
-        tagGroups,
-    };
-};

package/dist/src/functions/wirings/services/pikku-command-service-metadata.d.ts

@@ -1 +0,0 @@
-export declare const pikkuServiceMetadata: any;

package/dist/src/functions/wirings/services/pikku-command-service-metadata.js

@@ -1,22 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
-import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
-import { writeAllServiceMetadata } from '@pikku/inspector';
-export const pikkuServiceMetadata = pikkuSessionlessFunc({
-    func: async ({ logger, config, getInspectorState }) => {
-        const state = await getInspectorState();
-        // Only write service metadata if there are services to document
-        if (state.serviceMetadata && state.serviceMetadata.length > 0) {
-            writeAllServiceMetadata(state.serviceMetadata, config.outDir);
-            logger.debug(`• Wrote ${state.serviceMetadata.length} service metadata files`);
-        }
-        else {
-            logger.debug('• No service metadata to write');
-        }
-    },
-    middleware: [
-        logCommandInfoAndTime({
-            commandStart: 'Generating service metadata',
-            commandEnd: 'Generated service metadata',
-        }),
-    ],
-});

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

@@ -1 +0,0 @@
-export declare const pikkuWorkflowMap: any;

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

@@ -1,12 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
-import { writeFileInDir } from '../../../utils/file-writer.js';
-import { serializeWorkflowMap } from './serialize-workflow-map.js';
-export const pikkuWorkflowMap = pikkuSessionlessFunc({
-    func: async ({ logger, config, getInspectorState }) => {
-        const visitState = await getInspectorState();
-        const { workflowMapDeclarationFile, packageMappings } = config;
-        const { workflows, functions: functionState } = visitState;
-        const { typesMap } = functionState;
-        await writeFileInDir(logger, workflowMapDeclarationFile, serializeWorkflowMap(workflowMapDeclarationFile, packageMappings, typesMap, functionState.meta, workflows.meta));
-    },
-});

package/dist/src/functions/wirings/workflow/pikku-command-workflow-types.d.ts

@@ -1 +0,0 @@
-export declare const pikkuWorkflowTypes: any;

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

@@ -1,13 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
-import { writeFileInDir } from '../../../utils/file-writer.js';
-import { serializeWorkflowTypes } from './serialize-workflow-types.js';
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-export const pikkuWorkflowTypes = pikkuSessionlessFunc({
-    func: async ({ logger, config }) => {
-        const { workflowTypesFile, functionTypesFile, packageMappings } = config;
-        const functionTypesImportPath = getFileImportRelativePath(workflowTypesFile, functionTypesFile, packageMappings);
-        // Get RPC map import path
-        const rpcMapImportPath = getFileImportRelativePath(workflowTypesFile, config.rpcInternalMapDeclarationFile, packageMappings);
-        await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath, rpcMapImportPath));
-    },
-});

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

@@ -1,8 +0,0 @@
-/**
- * Generate workflow registration wirings
- * Imports all workflow functions and calls addWorkflow for each
- */
-export declare const serializeWorkflowWirings: (outputPath: string, workflowFiles: Map<string, {
-    path: string;
-    exportedName: string;
-}>, packageMappings?: Record<string, string>) => string;

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

@@ -1,30 +0,0 @@
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-/**
- * Generate workflow registration wirings
- * Imports all workflow functions and calls addWorkflow for each
- */
-export const serializeWorkflowWirings = (outputPath, workflowFiles, packageMappings = {}) => {
-    const imports = [];
-    const registrations = [];
-    // Sort by pikkuFuncName for consistent output
-    const sortedWorkflows = Array.from(workflowFiles.entries()).sort((a, b) => a[0].localeCompare(b[0]));
-    // Generate imports
-    for (const [, { path, exportedName }] of sortedWorkflows) {
-        const importPath = getFileImportRelativePath(outputPath, path, packageMappings);
-        imports.push(`import { ${exportedName} } from '${importPath}'`);
-    }
-    // Generate addWorkflow calls
-    for (const [pikkuFuncName, { exportedName }] of sortedWorkflows) {
-        registrations.push(`addWorkflow('${pikkuFuncName}', ${exportedName})`);
-    }
-    // Only import addWorkflow if there are workflows to register
-    const addWorkflowImport = sortedWorkflows.length > 0
-        ? `import { addWorkflow } from '@pikku/core/workflow'\n\n`
-        : '';
-    return `/**
- * Auto-generated workflow registrations
- * Do not edit manually - regenerate with 'npx pikku'
- */
-${addWorkflowImport}${imports.join('\n')}${imports.length > 0 ? '\n\n' : ''}${registrations.join('\n')}
-`;
-};

package/dist/src/utils/custom-types-generator.d.ts

@@ -1,2 +0,0 @@
-import { TypesMap } from '@pikku/inspector';
-export declare function generateCustomTypes(typesMap: TypesMap, requiredTypes: Set<string>): string;

package/dist/src/utils/custom-types-generator.js

@@ -1,43 +0,0 @@
-export function generateCustomTypes(typesMap, requiredTypes) {
-    return `
-// Custom types are those that are defined directly within generics
-// or are broken into simpler types
-${Array.from(typesMap.customTypes.entries())
-        .map(([name, { type, references }]) => {
-        references.forEach((refName) => {
-            // Skip __object types (including those with suffixes like __object_abc123)
-            // These are placeholder types created by the inspector for invalid/broken functions
-            // (e.g., functions with type errors or missing return statements). Attempting to
-            // import these would fail since the source files don't actually export __object.
-            if (refName !== '__object' && !refName.startsWith('__object_')) {
-                requiredTypes.add(refName);
-            }
-        });
-        // Extract type names from the type string that might not be in references
-        const typeString = type;
-        // Use regex to extract potential type names (PascalCase identifiers)
-        const typeNameRegex = /\b[A-Z][a-zA-Z0-9]*\b/g;
-        const potentialTypes = typeString.match(typeNameRegex) || [];
-        potentialTypes.forEach((typeName) => {
-            // Skip string literals and common keywords
-            if (typeString.includes(`"${typeName}"`) ||
-                ['Pick', 'Omit', 'Partial', 'Required', 'Record', 'Readonly'].includes(typeName)) {
-                return;
-            }
-            // Try to find this type in the typesMap and add it if found
-            try {
-                const typeMeta = typesMap.getTypeMeta(typeName);
-                if (typeMeta.path) {
-                    // Add originalName to preserve canonical import name
-                    requiredTypes.add(typeMeta.originalName);
-                }
-            }
-            catch (e) {
-                // Type not found in map (ambient/builtin type) - ignore it
-                // Do NOT add to requiredTypes to avoid crashes in serializeImportMap
-            }
-        });
-        return `export type ${name} = ${type}`;
-    })
-        .join('\n')}`;
-}

package/dist/src/utils/schema-generator.d.ts

@@ -1,6 +0,0 @@
-import { FunctionsMeta, JSONValue } from '@pikku/core';
-import { HTTPWiringsMeta } from '@pikku/core/http';
-import { TypesMap } from '@pikku/inspector';
-import { CLILogger } from '../services/cli-logger.service.js';
-export declare function generateSchemas(logger: CLILogger, tsconfig: string, typesMap: TypesMap, functionMeta: FunctionsMeta, httpWiringsMeta: HTTPWiringsMeta, additionalTypes?: string[], additionalProperties?: boolean): Promise<Record<string, JSONValue>>;
-export declare function saveSchemas(logger: CLILogger, schemaParentDir: string, schemas: Record<string, JSONValue>, typesMap: TypesMap, functionsMeta: FunctionsMeta, supportsImportAttributes: boolean, additionalTypes?: string[]): Promise<void>;

package/dist/src/utils/schema-generator.js

@@ -1,118 +0,0 @@
-import { createGenerator, RootlessError } from 'ts-json-schema-generator';
-import { writeFileInDir } from './file-writer.js';
-import { mkdir, writeFile } from 'fs/promises';
-import { ErrorCode } from '@pikku/inspector';
-export async function generateSchemas(logger, tsconfig, typesMap, functionMeta, httpWiringsMeta, additionalTypes, additionalProperties = false) {
-    const schemasSet = new Set(typesMap.customTypes.keys());
-    for (const { inputs, outputs } of Object.values(functionMeta)) {
-        const types = [...(inputs || []), ...(outputs || [])];
-        for (const type of types) {
-            try {
-                const uniqueName = typesMap.getUniqueName(type);
-                if (uniqueName) {
-                    schemasSet.add(uniqueName);
-                }
-            }
-            catch {
-                // Skip types not in typesMap (e.g., inline types in generated workflow workers)
-            }
-        }
-    }
-    for (const wiringRoutes of Object.values(httpWiringsMeta)) {
-        for (const { inputTypes } of Object.values(wiringRoutes)) {
-            if (inputTypes?.body) {
-                schemasSet.add(inputTypes.body);
-            }
-            if (inputTypes?.query) {
-                schemasSet.add(inputTypes.query);
-            }
-            if (inputTypes?.params) {
-                schemasSet.add(inputTypes.params);
-            }
-        }
-    }
-    // Add additional types from schemasFromTypes config
-    if (additionalTypes) {
-        for (const type of additionalTypes) {
-            schemasSet.add(type);
-        }
-    }
-    const generator = createGenerator({
-        tsconfig,
-        skipTypeCheck: true,
-        topRef: false,
-        discriminatorType: 'open-api',
-        expose: 'export',
-        jsDoc: 'extended',
-        sortProps: true,
-        strictTuples: false,
-        encodeRefs: false,
-        additionalProperties,
-    });
-    const schemas = {};
-    schemasSet.forEach((schema) => {
-        try {
-            schemas[schema] = generator.createSchema(schema);
-        }
-        catch (e) {
-            // Ignore rootless errors
-            if (e instanceof RootlessError) {
-                logger.error(`[${ErrorCode.SCHEMA_NO_ROOT}] Error generating schema since it has no root: ${schema}`);
-                return;
-            }
-            logger.error(`[${ErrorCode.SCHEMA_GENERATION_ERROR}] Error generating schema: ${schema}. Message: ${e.message}`);
-        }
-    });
-    return schemas;
-}
-export async function saveSchemas(logger, schemaParentDir, schemas, typesMap, functionsMeta, supportsImportAttributes, additionalTypes) {
-    await writeFileInDir(logger, `${schemaParentDir}/register.gen.ts`, 'export const empty = null;');
-    const desiredSchemas = new Set([
-        ...Object.values(functionsMeta)
-            .map(({ inputs, outputs }) => {
-            const types = [];
-            if (inputs?.[0]) {
-                try {
-                    types.push(typesMap.getUniqueName(inputs[0]));
-                }
-                catch {
-                    // Skip types not in typesMap (e.g., inline types in generated workflow workers)
-                }
-            }
-            if (outputs?.[0]) {
-                try {
-                    types.push(typesMap.getUniqueName(outputs[0]));
-                }
-                catch {
-                    // Skip types not in typesMap (e.g., inline types in generated workflow workers)
-                }
-            }
-            return types;
-        })
-            .flat()
-            .filter((s) => !!s &&
-            !['boolean', 'string', 'number', 'null', 'undefined'].includes(s)),
-        ...typesMap.customTypes.keys(),
-        ...(additionalTypes || []),
-    ]);
-    if (desiredSchemas.size === 0) {
-        logger.info(`• Skipping schemas since none found.\x1b[0m`);
-        return;
-    }
-    await mkdir(`${schemaParentDir}/schemas`, { recursive: true });
-    await Promise.all(Object.entries(schemas).map(async ([schemaName, schema]) => {
-        if (desiredSchemas.has(schemaName)) {
-            await writeFile(`${schemaParentDir}/schemas/${schemaName}.schema.json`, JSON.stringify(schema), 'utf-8');
-        }
-    }));
-    // Only include schemas that were successfully generated
-    const availableSchemas = Array.from(desiredSchemas).filter((schema) => schemas[schema]);
-    const schemaImports = availableSchemas
-        .map((schema) => `
-import * as ${schema} from './schemas/${schema}.schema.json' ${supportsImportAttributes ? `with { type: 'json' }` : ''}
-addSchema('${schema}', ${schema})
-`)
-        .join('\n');
-    await writeFileInDir(logger, `${schemaParentDir}/register.gen.ts`, `import { addSchema } from '@pikku/core/schema'
-${schemaImports}`, { logWrite: true });
-}

package/pikku.config.json

@@ -1,29 +0,0 @@
-{
-  "$schema": "https://raw.githubusercontent.com/pikkujs/pikku/refs/heads/main/packages/cli/cli.schema.json",
-  "tsconfig": "./tsconfig.json",
-  "srcDirectories": ["src", "bin", "types"],
-  "outDir": ".pikku",
-  "packageMappings": {
-    "../inspector/src": "@pikku/inspector"
-  },
-  "schemasFromTypes": ["PikkuCLIConfig"],
-  "websocketFile": ".pikku/pikku-websocket.gen.ts",
-  "supportsImportAttributes": true,
-  "schema": {
-    "supportsImportAttributes": true
-  },
-  "cli": {
-    "entrypoints": {
-      "pikku": [
-        ".pikku/cli/pikku-cli.gen.ts",
-        {
-          "type": "channel",
-          "wirePath": ".pikku/cli/pikku-cli-channel.ts",
-          "path": ".pikku/cli/pikku-cli-client.gen.ts",
-          "name": "pikku-cli",
-          "route": "/cli/pikku"
-        }
-      ]
-    }
-  }
-}

package/run-tests.sh

@@ -1,53 +0,0 @@
-#!/bin/bash
-
-# Enable nullglob to handle cases where no files match the pattern
-shopt -s nullglob
-
-# Initialize variables for options
-watch_mode=false
-coverage_mode=false
-
-# Parse command-line options
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --watch)
-      watch_mode=true
-      shift
-      ;;
-    --coverage)
-      coverage_mode=true
-      shift
-      ;;
-    *)
-      echo "Unknown option: $1"
-      exit 1
-      ;;
-  esac
-done
-
-# Define the pattern to match your test files
-pattern="src/*.test.ts"
-
-# Expand the pattern into an array of files
-files=($(find src -type f -name "*.test.ts"))
-
-# Check if any files matched the pattern
-if [ ${#files[@]} -eq 0 ]; then
-  echo "No test files found matching pattern: $pattern"
-  exit 0
-fi
-
-# Construct the node command
-node_cmd="node --import tsx --test"
-
-# Append options based on flags
-if [ "$watch_mode" = true ]; then
-  node_cmd="$node_cmd --watch"
-fi
-
-if [ "$coverage_mode" = true ]; then
-  node_cmd="$node_cmd --test-coverage-include=\"src/**/*.{ts,js}\" --test-coverage-exclude=\"**/dist/**\" --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info"
-fi
-
-# Execute the node command with the expanded list of files
-$node_cmd "${files[@]}"

package/src/cli.wiring.ts

@@ -1,112 +0,0 @@
-import { pikkuSchemas } from './functions/wirings/functions/schemas.js'
-import { pikkuFetch } from './functions/wirings/fetch/index.js'
-import { pikkuWebSocketTyped } from './functions/wirings/channels/pikku-command-websocket-typed.js'
-import { pikkuRPCClient } from './functions/wirings/rpc/pikku-command-rpc-client.js'
-import { pikkuQueueService } from './functions/wirings/queue/pikku-command-queue-service.js'
-import { pikkuOpenAPI } from './functions/wirings/http/pikku-command-openapi.js'
-import { pikkuNext } from './functions/runtimes/nextjs/pikku-command-nextjs.js'
-import { pikkuCLICommand, wireCLI } from '../.pikku/cli/pikku-cli-types.gen.js'
-import { all } from './functions/commands/all.js'
-import { bootstrap } from './functions/commands/bootstrap.js'
-import { watch } from './functions/commands/watch.js'
-// import { clientCLIRenderer } from './services.js'
-
-wireCLI({
-  program: 'pikku',
-  description:
-    'Pikku CLI - Code generation tool for type-safe backend development',
-  // render: clientCLIRenderer,
-  options: {
-    config: {
-      description: 'Path to pikku.config.json file',
-      short: 'c',
-    },
-    logLevel: {
-      description: 'Set log level',
-      default: 'info' as const,
-      short: 'l',
-    },
-    userSessionType: {
-      description:
-        'Specify which UserSession type to use (when multiple exist)',
-    },
-    singletonServicesFactoryType: {
-      description: 'Specify which singleton services factory to use',
-    },
-    wireServicesFactoryType: {
-      description: 'Specify which wire services factory to use',
-    },
-    stateOutput: {
-      description: 'Save inspector state to JSON file for reuse',
-    },
-    stateInput: {
-      description: 'Load inspector state from JSON file (skips inspection)',
-    },
-  },
-  commands: {
-    all: pikkuCLICommand({
-      func: all,
-      description: 'Generate all Pikku files (types, schemas, wirings, etc.)',
-      isDefault: true,
-      options: {
-        tags: {
-          description: 'Filter functions by tags (comma-separated)',
-          short: 't',
-        },
-        types: {
-          description: 'Filter functions by types (comma-separated)',
-        },
-        directories: {
-          description: 'Filter functions by directories (comma-separated)',
-          short: 'd',
-        },
-        httpMethods: {
-          description: 'Filter HTTP routes by methods (comma-separated)',
-        },
-        httpRoutes: {
-          description: 'Filter HTTP routes by route patterns (comma-separated)',
-        },
-        names: {
-          description: 'Filter functions by name patterns (supports wildcards)',
-          short: 'n',
-        },
-      },
-    }),
-    bootstrap: pikkuCLICommand({
-      func: bootstrap,
-      description: 'Generate only type files (setup phase only)',
-    }),
-    watch: pikkuCLICommand({
-      func: watch,
-      description: 'Watch for file changes and regenerate automatically',
-    }),
-    schemas: pikkuCLICommand({
-      func: pikkuSchemas,
-      description: 'Generate JSON schemas for function input/output types',
-    }),
-    fetch: pikkuCLICommand({
-      func: pikkuFetch,
-      description: 'Generate type-safe HTTP fetch client',
-    }),
-    websocket: pikkuCLICommand({
-      func: pikkuWebSocketTyped,
-      description: 'Generate type-safe WebSocket client',
-    }),
-    rpc: pikkuCLICommand({
-      func: pikkuRPCClient,
-      description: 'Generate RPC client wrappers',
-    }),
-    'queue-service': pikkuCLICommand({
-      func: pikkuQueueService,
-      description: 'Generate queue service wrapper',
-    }),
-    openapi: pikkuCLICommand({
-      func: pikkuOpenAPI,
-      description: 'Generate OpenAPI specification from HTTP routes',
-    }),
-    nextjs: pikkuCLICommand({
-      func: pikkuNext,
-      description: 'Generate Next.js backend and HTTP wrappers',
-    }),
-  },
-})