@pikku/cli 0.11.2 → 0.12.0

package/bin/pikku.ts

@@ -1,88 +0,0 @@
-#!/usr/bin/env node
-import { Command } from 'commander'
-import { createConfig, createSingletonServices } from '../src/services.js'
-import { LocalVariablesService } from '@pikku/core/services'
-import { all as allCommand } from '../src/functions/commands/all.js'
-import { watch as watchCommand } from '../src/functions/commands/watch.js'
-
-// Import bootstrap if it exists
-try {
-  await import('../.pikku/pikku-bootstrap.gen.js')
-} catch {
-  // Bootstrap doesn't exist yet, continue anyway
-}
-
-const action = async (command: string, cliConfig: any) => {
-  const config = await createConfig(new LocalVariablesService(), cliConfig)
-  const services = await createSingletonServices(config)
-
-  if (command === 'watch') {
-    await watchCommand.func(services)
-  } else {
-    await allCommand.func(services)
-  }
-}
-
-const all = (program, name, description) => {
-  program
-    .command(name, { isDefault: name === 'all' })
-    .description(description)
-    .option('--pikku-config-type', 'The type of your pikku config object')
-    .option(
-      '--singleton-services-factory-type',
-      'The type of your singleton services factory'
-    )
-    .option(
-      '--session-services-factory-type',
-      'The type of your wire services factory'
-    )
-    .option('-c, --config <string>', 'The path to pikku cli config file')
-    .option('-t, --tags <tags...>', 'Which tags to filter by')
-    .option(
-      '--types <types...>',
-      'Which types to filter by (http, channel, queue, scheduler, rpc, mcp)'
-    )
-    .option(
-      '-d, --directories <directories...>',
-      'Which directories to filter by'
-    )
-    .option(
-      '-n, --names <names...>',
-      'Filter functions by name patterns (supports wildcards)'
-    )
-    .option(
-      '--httpMethods <methods...>',
-      'Filter HTTP routes by methods (comma-separated)'
-    )
-    .option(
-      '--httpRoutes <routes...>',
-      'Filter HTTP routes by route patterns (comma-separated)'
-    )
-    .option('-s, --silent', 'Silent mode - only show critical errors')
-    .option(
-      '--info',
-      'Show info messages and above (info, warn, error, critical)'
-    )
-    .option('--verbose', 'Show all debug messages (most detailed)')
-    .option(
-      '--loglevel <level>',
-      'Set explicit log level (trace, debug, info, warn, error, critical)'
-    )
-    .option(
-      '--state-output <path>',
-      'Save inspector state to JSON file for reuse'
-    )
-    .option(
-      '--state-input <path>',
-      'Load inspector state from JSON file (skips inspection)'
-    )
-    .action((c) => action(name, c))
-}
-
-const program = new Command('pikku')
-program.usage('[command]')
-
-all(program, 'all', 'Generate all pikku wirings and files')
-all(program, 'watch', 'Watch for changes in pikku files')
-
-program.parse(process.argv)

package/build.sh

@@ -1,75 +0,0 @@
-#!/bin/bash
-
-set -e
-
-echo "Starting Pikku CLI build process..."
-
-# Clean .pikku directory
-rm -rf .pikku
-
-# Create minimal bootstrap stub files
-echo "Creating minimal bootstrap stub files..."
-mkdir -p .pikku/function .pikku/cli
-
-cat > .pikku/pikku-types.gen.ts << 'EOF'
-/**
- * Bootstrap stub - minimal types for initial build
- */
-export * from './function/pikku-function-types.gen.js'
-export * from './cli/pikku-cli-types.gen.js'
-EOF
-
-cat > .pikku/function/pikku-function-types.gen.ts << 'EOF'
-/**
- * Bootstrap stub - minimal function types
- */
-export const pikkuFunc = <In, Out = unknown>(func: any) => {
-  return typeof func === 'function' ? { func } : func
-}
-
-export const pikkuSessionlessFunc = <In, Out = unknown>(func: any) => {
-  return typeof func === 'function' ? { func } : func
-}
-
-export const pikkuVoidFunc = (func: any) => {
-  return typeof func === 'function' ? { func } : func
-}
-EOF
-
-cat > .pikku/cli/pikku-cli-types.gen.ts << 'EOF'
-/**
- * Bootstrap stub - minimal CLI types
- */
-export { wireCLI } from '@pikku/core/cli'
-
-export const pikkuCLICommand = (config: any) => {
-  return config
-}
-EOF
-
-cat > .pikku/pikku-bootstrap.gen.ts << 'EOF'
-/**
- * Bootstrap stub - empty bootstrap file
- */
-EOF
-
-# Build TypeScript with stubs
-echo "Building TypeScript to dist..."
-yarn tsc -b
-
-# Regenerate types with newly built CLI
-echo "Removing .pikku directory (generated from published version)..."
-rm -rf .pikku
-
-echo "Regenerating Pikku types using local CLI..."
-yarn pikku
-
-# Rebuild with generated types
-echo "Rebuilding TypeScript with local types..."
-yarn tsc -b
-
-# Copy schema file
-echo "Copying schema file..."
-cp .pikku/schemas/schemas/PikkuCLIConfig.schema.json cli.schema.json
-
-echo "Build complete! ✓"

package/dist/.pikku/function/pikku-functions-meta.min.gen.js

@@ -1,6 +0,0 @@
-/**
- * This file was generated by @pikku/cli@0.11.2
- */
-import { pikkuState } from '@pikku/core';
-import metaData from './pikku-functions-meta.min.gen.json' with { type: 'json' };
-pikkuState('function', 'meta', metaData);

package/dist/.pikku/function/pikku-functions-meta.min.gen.json

@@ -1,212 +0,0 @@
-{
-    "pikkuSchemas": {
-        "pikkuFuncName": "pikkuSchemas",
-        "inputSchemaName": null,
-        "outputSchemaName": "PikkuSchemasOutput"
-    },
-    "pikkuFetch": {
-        "pikkuFuncName": "pikkuFetch",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuWebSocketTyped": {
-        "pikkuFuncName": "pikkuWebSocketTyped",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuRPCClient": {
-        "pikkuFuncName": "pikkuRPCClient",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuQueueService": {
-        "pikkuFuncName": "pikkuQueueService",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuOpenAPI": {
-        "pikkuFuncName": "pikkuOpenAPI",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuNext": {
-        "pikkuFuncName": "pikkuNext",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuFunctionTypes": {
-        "pikkuFuncName": "pikkuFunctionTypes",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuFunctionTypesSplit": {
-        "pikkuFuncName": "pikkuFunctionTypesSplit",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuHTTPTypes": {
-        "pikkuFuncName": "pikkuHTTPTypes",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuChannelTypes": {
-        "pikkuFuncName": "pikkuChannelTypes",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuSchedulerTypes": {
-        "pikkuFuncName": "pikkuSchedulerTypes",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuQueueTypes": {
-        "pikkuFuncName": "pikkuQueueTypes",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuWorkflowTypes": {
-        "pikkuFuncName": "pikkuWorkflowTypes",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuMCPTypes": {
-        "pikkuFuncName": "pikkuMCPTypes",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuCLITypes": {
-        "pikkuFuncName": "pikkuCLITypes",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuFunctions": {
-        "pikkuFuncName": "pikkuFunctions",
-        "inputSchemaName": null,
-        "outputSchemaName": "PikkuFunctionsOutput"
-    },
-    "pikkuMiddleware": {
-        "pikkuFuncName": "pikkuMiddleware",
-        "inputSchemaName": null,
-        "outputSchemaName": "PikkuMiddlewareOutput"
-    },
-    "pikkuPermissions": {
-        "pikkuFuncName": "pikkuPermissions",
-        "inputSchemaName": null,
-        "outputSchemaName": "PikkuPermissionsOutput"
-    },
-    "pikkuServices": {
-        "pikkuFuncName": "pikkuServices",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuServiceMetadata": {
-        "pikkuFuncName": "pikkuServiceMetadata",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuRPC": {
-        "pikkuFuncName": "pikkuRPC",
-        "inputSchemaName": null,
-        "outputSchemaName": "PikkuRPCOutput"
-    },
-    "pikkuRPCInternalMap": {
-        "pikkuFuncName": "pikkuRPCInternalMap",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuRPCExposedMap": {
-        "pikkuFuncName": "pikkuRPCExposedMap",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuPublicRPC": {
-        "pikkuFuncName": "pikkuPublicRPC",
-        "inputSchemaName": null,
-        "outputSchemaName": "PikkuPublicRPCOutput"
-    },
-    "pikkuHTTP": {
-        "pikkuFuncName": "pikkuHTTP",
-        "inputSchemaName": null,
-        "outputSchemaName": "PikkuHTTPOutput"
-    },
-    "pikkuHTTPMap": {
-        "pikkuFuncName": "pikkuHTTPMap",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuScheduler": {
-        "pikkuFuncName": "pikkuScheduler",
-        "inputSchemaName": null,
-        "outputSchemaName": "PikkuSchedulerOutput"
-    },
-    "pikkuWorkflow": {
-        "pikkuFuncName": "pikkuWorkflow",
-        "inputSchemaName": null,
-        "outputSchemaName": "PikkuWorkflowOutput"
-    },
-    "pikkuRemoteRPC": {
-        "pikkuFuncName": "pikkuRemoteRPC",
-        "inputSchemaName": null,
-        "outputSchemaName": "PikkuRemoteRPCOutput"
-    },
-    "pikkuWorkflowMap": {
-        "pikkuFuncName": "pikkuWorkflowMap",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuQueue": {
-        "pikkuFuncName": "pikkuQueue",
-        "inputSchemaName": null,
-        "outputSchemaName": "PikkuQueueOutput"
-    },
-    "pikkuQueueMap": {
-        "pikkuFuncName": "pikkuQueueMap",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuChannels": {
-        "pikkuFuncName": "pikkuChannels",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuChannelsMap": {
-        "pikkuFuncName": "pikkuChannelsMap",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuMCP": {
-        "pikkuFuncName": "pikkuMCP",
-        "inputSchemaName": null,
-        "outputSchemaName": "PikkuMCPOutput"
-    },
-    "pikkuMCPJSON": {
-        "pikkuFuncName": "pikkuMCPJSON",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "pikkuCLI": {
-        "pikkuFuncName": "pikkuCLI",
-        "inputSchemaName": null,
-        "outputSchemaName": "PikkuCLIOutput"
-    },
-    "pikkuCLIEntry": {
-        "pikkuFuncName": "pikkuCLIEntry",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "all": {
-        "pikkuFuncName": "all",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "bootstrap": {
-        "pikkuFuncName": "bootstrap",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    },
-    "watch": {
-        "pikkuFuncName": "watch",
-        "inputSchemaName": null,
-        "outputSchemaName": null
-    }
-}

package/dist/src/functions/wirings/channels/pikku-command-websocket-typed.d.ts

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

package/dist/src/functions/wirings/fetch/index.d.ts

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

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

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

package/dist/src/functions/wirings/functions/pikku-function-types.js

@@ -1,18 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-import { writeFileInDir } from '../../../utils/file-writer.js';
-import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
-import { serializePikkuTypesHub } from './serialize-pikku-types-hub.js';
-export const pikkuFunctionTypes = pikkuSessionlessFunc({
-    func: async ({ logger, config }) => {
-        const { typesDeclarationFile: typesFile, packageMappings, functionTypesFile, httpTypesFile, channelsTypesFile, schedulersTypesFile, queueTypesFile, mcpTypesFile, cliTypesFile, } = config;
-        const content = serializePikkuTypesHub(getFileImportRelativePath(typesFile, functionTypesFile, packageMappings), getFileImportRelativePath(typesFile, httpTypesFile, packageMappings), getFileImportRelativePath(typesFile, channelsTypesFile, packageMappings), getFileImportRelativePath(typesFile, schedulersTypesFile, packageMappings), getFileImportRelativePath(typesFile, queueTypesFile, packageMappings), getFileImportRelativePath(typesFile, mcpTypesFile, packageMappings), getFileImportRelativePath(typesFile, cliTypesFile, packageMappings));
-        await writeFileInDir(logger, typesFile, content);
-    },
-    middleware: [
-        logCommandInfoAndTime({
-            commandStart: 'Creating api types hub',
-            commandEnd: 'Created api types hub',
-        }),
-    ],
-});

package/dist/src/functions/wirings/http/openapi-spec-generator.d.ts

@@ -1,81 +0,0 @@
-import { FunctionsMeta } from '@pikku/core';
-import { HTTPWiringsMeta } from '@pikku/core/http';
-import { CLILogger } from '../../../services/cli-logger.service.js';
-interface OpenAPISpec {
-    openapi: string;
-    info: {
-        title: string;
-        version: string;
-        description?: string;
-        termsOfService?: string;
-        contact?: {
-            name?: string;
-            url?: string;
-            email?: string;
-        };
-        license?: {
-            name: string;
-            url?: string;
-        };
-    };
-    servers: {
-        url: string;
-        description?: string;
-    }[];
-    paths: Record<string, any>;
-    components: {
-        schemas: Record<string, any>;
-        responses?: Record<string, any>;
-        parameters?: Record<string, any>;
-        examples?: Record<string, any>;
-        requestBodies?: Record<string, any>;
-        headers?: Record<string, any>;
-        securitySchemes?: Record<string, any>;
-    };
-    security?: {
-        [key: string]: any[];
-    }[];
-    tags?: {
-        name: string;
-        description?: string;
-    }[];
-    externalDocs?: {
-        description?: string;
-        url: string;
-    };
-}
-export interface OpenAPISpecInfo {
-    info: {
-        title: string;
-        version: string;
-        description: string;
-        termsOfService?: string;
-        contact?: {
-            name?: string;
-            url?: string;
-            email?: string;
-        };
-        license?: {
-            name: string;
-            url?: string;
-        };
-    };
-    servers: {
-        url: string;
-        description?: string;
-    }[];
-    tags?: {
-        name: string;
-        description?: string;
-    }[];
-    externalDocs?: {
-        description?: string;
-        url: string;
-    };
-    securitySchemes?: Record<string, any>;
-    security?: {
-        [key: string]: any[];
-    }[];
-}
-export declare function generateOpenAPISpec(logger: CLILogger, functionsMeta: FunctionsMeta, httpMeta: HTTPWiringsMeta, schemas: Record<string, any>, additionalInfo: OpenAPISpecInfo): Promise<OpenAPISpec>;
-export {};

package/dist/src/functions/wirings/http/openapi-spec-generator.js

@@ -1,152 +0,0 @@
-import { pikkuState } from '@pikku/core';
-import _convertSchema from '@openapi-contrib/json-schema-to-openapi-schema';
-const convertSchema = 'default' in _convertSchema ? _convertSchema.default : _convertSchema;
-const getErrorResponseForConstructorName = (constructorName) => {
-    const errors = Array.from(pikkuState('misc', 'errors').entries());
-    const foundError = errors.find(([e]) => e.name === constructorName);
-    if (foundError) {
-        return foundError[1];
-    }
-    return undefined;
-};
-const convertSchemasToBodyPayloads = async (functionsMeta, routesMeta, schemas) => {
-    const requiredSchemas = new Set();
-    for (const routeMeta of Object.values(routesMeta)) {
-        for (const { inputTypes, pikkuFuncName } of Object.values(routeMeta)) {
-            const output = functionsMeta[pikkuFuncName]?.outputs?.[0];
-            if (inputTypes?.body) {
-                requiredSchemas.add(inputTypes?.body);
-            }
-            if (output) {
-                requiredSchemas.add(output);
-            }
-        }
-    }
-    const convertedEntries = await Promise.all(Object.entries(schemas).map(async ([key, schema]) => {
-        if (requiredSchemas.has(key)) {
-            const convertedSchema = await convertSchema(schema, {
-                convertUnreferencedDefinitions: false,
-                dereference: { circular: 'ignore' },
-            });
-            return [key, convertedSchema];
-        }
-        return;
-    }));
-    return Object.fromEntries(convertedEntries.filter((s) => !!s));
-};
-export async function generateOpenAPISpec(logger, functionsMeta, httpMeta, schemas, additionalInfo) {
-    const paths = {};
-    for (const routeMeta of Object.values(httpMeta)) {
-        for (const meta of Object.values(routeMeta)) {
-            const { route, method, inputTypes, pikkuFuncName, params, query, errors, description, tags, } = meta;
-            const functionMeta = functionsMeta[pikkuFuncName];
-            if (!functionMeta) {
-                logger.error(`• No function metadata found for '${pikkuFuncName}' in route '${route}'.`);
-                continue;
-            }
-            const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
-            const path = route.replace(/:(\w+)/g, '{$1}'); // Convert ":param" to "{param}"
-            if (!paths[path]) {
-                paths[path] = {};
-            }
-            const responses = {};
-            errors?.forEach((error) => {
-                const errorResponse = getErrorResponseForConstructorName(error);
-                if (errorResponse) {
-                    responses[errorResponse.status] = {
-                        description: errorResponse.message,
-                    };
-                }
-            });
-            const operation = {
-                description: description ||
-                    `This endpoint handles the ${method.toUpperCase()} request for the route ${route}.`,
-                tags: tags || [route.split('/')[1] || 'default'],
-                parameters: [],
-                responses: {
-                    ...responses,
-                    '200': {
-                        description: 'Successful response',
-                        content: output
-                            ? {
-                                'application/json': {
-                                    schema: typeof output === 'string' &&
-                                        ['boolean', 'string', 'number'].includes(output)
-                                        ? { type: output }
-                                        : { $ref: `#/components/schemas/${output}` },
-                                },
-                            }
-                            : undefined,
-                    },
-                },
-            };
-            const bodyType = inputTypes?.body;
-            if (bodyType) {
-                operation.requestBody = {
-                    required: true,
-                    content: {
-                        'application/json': {
-                            schema: typeof bodyType === 'string' &&
-                                ['boolean', 'string', 'number'].includes(bodyType)
-                                ? { type: bodyType }
-                                : { $ref: `#/components/schemas/${bodyType}` },
-                        },
-                    },
-                };
-            }
-            if (params) {
-                operation.parameters = params.map((param) => ({
-                    name: param,
-                    in: 'path',
-                    required: true,
-                    schema: { type: 'string' },
-                }));
-            }
-            if (query) {
-                operation.parameters.push(...query.map((query) => ({
-                    name: query,
-                    in: 'query',
-                    required: false,
-                    schema: { type: 'string' },
-                })));
-            }
-            paths[path][method] = operation;
-        }
-    }
-    return {
-        openapi: '3.1.0',
-        info: additionalInfo.info,
-        servers: additionalInfo.servers,
-        paths,
-        components: {
-            schemas: await convertSchemasToBodyPayloads(functionsMeta, httpMeta, schemas),
-            responses: {},
-            parameters: {},
-            examples: {},
-            requestBodies: {},
-            headers: {},
-            securitySchemes: additionalInfo.securitySchemes || {
-                ApiKeyAuth: {
-                    type: 'apiKey',
-                    in: 'header',
-                    name: 'x-api-key',
-                },
-                BearerAuth: {
-                    type: 'http',
-                    scheme: 'bearer',
-                },
-            },
-        },
-        security: additionalInfo.security || [
-            {
-                ApiKeyAuth: [],
-            },
-            {
-                BearerAuth: [],
-            },
-        ],
-        tags: additionalInfo.tags,
-        externalDocs: additionalInfo.externalDocs,
-        // definitions
-    };
-}

package/dist/src/functions/wirings/mcp/serialize-mcp-json.d.ts

@@ -1,5 +0,0 @@
-import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp';
-import { FunctionsMeta } from '@pikku/core';
-import { TypesMap } from '@pikku/inspector';
-import { CLILogger } from '../../../services/cli-logger.service.js';
-export declare const serializeMCPJson: (logger: CLILogger, schemaDirectory: string, functionsMeta: FunctionsMeta, typesMap: TypesMap, mcpResourceMeta: MCPResourceMeta, mcpToolMeta: MCPToolMeta, mcpPromptMeta: MCPPromptMeta) => Promise<string>;