@pikku/cli 0.11.3 → 0.12.1

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(null, '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>;

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

@@ -1,102 +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;
-        }
-        const schemaPath = join(schemaDirectory, 'schemas', `${uniqueName}.schema.json`);
-        try {
-            const schemaContent = await readFile(schemaPath, 'utf-8');
-            return JSON.parse(schemaContent);
-        }
-        catch (e) {
-            logger.warn(`Serialize MCP: Could not load schema for type: ${uniqueName} from ${schemaPath}`);
-            console.error(e);
-            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/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,41 +0,0 @@
-// Sanitize a type name to be a valid TypeScript identifier
-function sanitizeTypeName(name) {
-    // Replace hyphens with underscores
-    return name.replace(/-/g, '_');
-}
-export function generateCustomTypes(typesMap, requiredTypes) {
-    return `
-${Array.from(typesMap.customTypes.entries())
-        .filter(([_name, { type }]) => {
-        const hasUndefinedGeneric = /\b(Name|In|Out|Key)\b/.test(type) && /\[.*\]/.test(type);
-        return !hasUndefinedGeneric;
-    })
-        .map(([originalName, { type, references }]) => {
-        const name = sanitizeTypeName(originalName);
-        references.forEach((refName) => {
-            if (refName !== '__object' && !refName.startsWith('__object_')) {
-                requiredTypes.add(refName);
-            }
-        });
-        const typeString = type;
-        const typeNameRegex = /\b[A-Z][a-zA-Z0-9]*\b/g;
-        const potentialTypes = typeString.match(typeNameRegex) || [];
-        potentialTypes.forEach((typeName) => {
-            if (typeString.includes(`"${typeName}"`) ||
-                ['Pick', 'Omit', 'Partial', 'Required', 'Record', 'Readonly'].includes(typeName)) {
-                return;
-            }
-            try {
-                const typeMeta = typesMap.getTypeMeta(typeName);
-                if (typeMeta.path) {
-                    requiredTypes.add(typeMeta.originalName);
-                }
-            }
-            catch {
-                // Type not found in map (ambient/builtin type)
-            }
-        });
-        return `export type ${name} = ${type}`;
-    })
-        .join('\n')}`;
-}

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

@@ -1,7 +0,0 @@
-import { FunctionsMeta, JSONValue } from '@pikku/core';
-import { HTTPWiringsMeta } from '@pikku/core/http';
-import { TypesMap, ZodSchemaRef } 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, zodLookup?: Map<string, ZodSchemaRef>): Promise<Record<string, JSONValue>>;
-export declare function generateZodSchemas(logger: CLILogger, zodLookup: Map<string, ZodSchemaRef>, typesMap: TypesMap): Promise<Record<string, JSONValue>>;
-export declare function saveSchemas(logger: CLILogger, schemaParentDir: string, schemas: Record<string, JSONValue>, typesMap: TypesMap, functionsMeta: FunctionsMeta, supportsImportAttributes: boolean, additionalTypes?: string[], zodLookup?: Map<string, ZodSchemaRef>, packageName?: string | null): Promise<void>;

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

@@ -1,238 +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';
-import { tsImport } from 'tsx/esm/api';
-import * as z from 'zod';
-import { zodToTs, createAuxiliaryTypeStore } from 'zod-to-ts';
-import { createPrinter, createSourceFile, EmitHint, ScriptKind, ScriptTarget, } from 'typescript';
-/**
- * Convert a name to a valid JavaScript identifier.
- * Replaces hyphens and other invalid characters with underscores.
- */
-function toValidIdentifier(name) {
-    let result = name.replace(/[-./]/g, '_');
-    if (/^\d/.test(result)) {
-        result = '_' + result;
-    }
-    return result;
-}
-const PRIMITIVE_TYPES = new Set([
-    'boolean',
-    'string',
-    'number',
-    'null',
-    'undefined',
-    'void',
-    'any',
-    'unknown',
-    'never',
-]);
-/** Map TypeScript type strings to JSON Schema. Returns null if no schema should be generated. */
-function primitiveTypeToSchema(typeStr) {
-    const normalized = typeStr.trim();
-    // void/undefined/never mean no data - don't generate a schema
-    if (normalized === 'void' ||
-        normalized === 'undefined' ||
-        normalized === 'never') {
-        return null;
-    }
-    // Handle boolean literals
-    if (normalized === 'boolean' ||
-        normalized === 'false | true' ||
-        normalized === 'true | false') {
-        return { type: 'boolean' };
-    }
-    if (normalized === 'true') {
-        return { const: true };
-    }
-    if (normalized === 'false') {
-        return { const: false };
-    }
-    // Handle string
-    if (normalized === 'string') {
-        return { type: 'string' };
-    }
-    // Handle number
-    if (normalized === 'number') {
-        return { type: 'number' };
-    }
-    // Handle null
-    if (normalized === 'null') {
-        return { type: 'null' };
-    }
-    return null;
-}
-export async function generateSchemas(logger, tsconfig, typesMap, functionMeta, httpWiringsMeta, additionalTypes, additionalProperties = false, zodLookup) {
-    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);
-            }
-        }
-    }
-    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) => {
-        if (PRIMITIVE_TYPES.has(schema)) {
-            return;
-        }
-        if (zodLookup?.has(schema)) {
-            return;
-        }
-        try {
-            schemas[schema] = generator.createSchema(schema);
-        }
-        catch (e) {
-            if (e instanceof RootlessError) {
-                const customType = typesMap.customTypes.get(schema);
-                if (customType) {
-                    const primitiveSchema = primitiveTypeToSchema(customType.type);
-                    if (primitiveSchema) {
-                        schemas[schema] = primitiveSchema;
-                    }
-                }
-                return;
-            }
-            const customType = typesMap.customTypes.get(schema);
-            logger.error(`[${ErrorCode.SCHEMA_GENERATION_ERROR}] Error generating schema: ${schema}. Message: ${e.message}. Type info: ${customType ? `type=${customType.type}` : 'not in typesMap'}`);
-        }
-    });
-    return schemas;
-}
-export async function generateZodSchemas(logger, zodLookup, typesMap) {
-    const schemas = {};
-    const auxiliaryTypeStore = createAuxiliaryTypeStore();
-    const printer = createPrinter();
-    const fakeSourceFile = createSourceFile('zod-types.ts', '', ScriptTarget.ESNext, false, ScriptKind.TS);
-    for (const [schemaName, ref] of zodLookup.entries()) {
-        try {
-            const module = await tsImport(ref.sourceFile, import.meta.url);
-            const zodSchema = module[ref.variableName];
-            if (!zodSchema) {
-                logger.warn(`Could not find exported schema '${ref.variableName}' in ${ref.sourceFile} for ${schemaName}. Available exports: ${Object.keys(module).join(', ')}`);
-                continue;
-            }
-            const schema = z.toJSONSchema(zodSchema);
-            // Remove fields with defaults from the required array
-            // Fields with defaults are semantically optional in input validation
-            if (schema.required && schema.properties) {
-                schema.required = schema.required.filter((fieldName) => {
-                    const prop = schema.properties[fieldName];
-                    return prop && prop.default === undefined;
-                });
-                if (schema.required.length === 0) {
-                    delete schema.required;
-                }
-            }
-            schemas[schemaName] = schema;
-            const { node: tsType } = zodToTs(zodSchema, { auxiliaryTypeStore });
-            const typeText = printer.printNode(EmitHint.Unspecified, tsType, fakeSourceFile);
-            typesMap.addCustomType(schemaName, typeText, []);
-            logger.info(`• Generated schema from Zod: ${schemaName}`);
-        }
-        catch (e) {
-            logger.warn(`Could not convert Zod schema '${schemaName}': ${e instanceof Error ? e.message : e}`);
-        }
-    }
-    return schemas;
-}
-export async function saveSchemas(logger, schemaParentDir, schemas, typesMap, functionsMeta, supportsImportAttributes, additionalTypes, zodLookup, packageName) {
-    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 - might be a zod schema name
-                    types.push(inputs[0]);
-                }
-            }
-            if (outputs?.[0]) {
-                try {
-                    types.push(typesMap.getUniqueName(outputs[0]));
-                }
-                catch {
-                    // Skip types not in typesMap - might be a zod schema name
-                    types.push(outputs[0]);
-                }
-            }
-            return types;
-        })
-            .flat()
-            .filter((s) => !!s && !PRIMITIVE_TYPES.has(s)),
-        ...typesMap.customTypes.keys(),
-        ...(additionalTypes || []),
-        ...(zodLookup ? Array.from(zodLookup.keys()) : []),
-    ]);
-    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]);
-    // Generate the packageName argument for addSchema calls
-    const packageNameArg = packageName ? `, '${packageName}'` : '';
-    const schemaImports = availableSchemas
-        .map((schema) => {
-        const identifier = toValidIdentifier(schema);
-        return `
-import * as ${identifier} from './schemas/${schema}.schema.json' ${supportsImportAttributes ? `with { type: 'json' }` : ''}
-addSchema('${schema}', ${identifier}${packageNameArg})
-`;
-    })
-        .join('\n');
-    // Only import addSchema if there are schemas to register
-    const importStatement = availableSchemas.length > 0
-        ? `import { addSchema } from '@pikku/core/schema'`
-        : '// No schemas to register';
-    await writeFileInDir(logger, `${schemaParentDir}/register.gen.ts`, `${importStatement}
-${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"
-        }
-      ]
-    }
-  }
-}