@pikku/cli 0.12.0 → 0.12.2

package/dist/src/utils/openapi/parse-openapi.js

@@ -0,0 +1,196 @@
+/**
+ * Parses OpenAPI YAML/JSON specs, resolves $ref pointers, and produces a normalized IR.
+ */
+import { readFile } from 'fs/promises';
+import { parse as parseYAML } from 'yaml';
+/**
+ * Read and parse an OpenAPI spec from a file path.
+ * Supports both YAML (.yaml, .yml) and JSON (.json) files.
+ */
+export async function parseOpenAPISpec(filePath) {
+    const content = await readFile(filePath, 'utf-8');
+    let doc;
+    if (filePath.endsWith('.json')) {
+        doc = JSON.parse(content);
+    }
+    else {
+        doc = parseYAML(content);
+    }
+    // Resolve all $ref pointers in-place
+    resolveRefs(doc, doc);
+    const info = {
+        title: doc.info?.title ?? 'Unknown API',
+        version: doc.info?.version ?? '1.0.0',
+        description: doc.info?.description,
+    };
+    const baseUrl = extractBaseUrl(doc);
+    const authType = detectAuthType(doc);
+    // Extract component schemas
+    const componentSchemas = {};
+    if (doc.components?.schemas) {
+        for (const [name, schema] of Object.entries(doc.components.schemas)) {
+            componentSchemas[name] = schema;
+        }
+    }
+    // Extract operations
+    const operations = [];
+    if (doc.paths) {
+        for (const [path, pathItem] of Object.entries(doc.paths)) {
+            // Shared parameters at the path level
+            const sharedParams = pathItem.parameters ?? [];
+            for (const method of ['get', 'post', 'put', 'patch', 'delete']) {
+                const op = pathItem[method];
+                if (!op)
+                    continue;
+                const allParams = [...sharedParams, ...(op.parameters ?? [])];
+                operations.push({
+                    operationId: op.operationId,
+                    method,
+                    path,
+                    summary: op.summary,
+                    description: op.description,
+                    tags: op.tags ?? [],
+                    pathParams: extractParams(allParams, 'path'),
+                    queryParams: extractParams(allParams, 'query'),
+                    requestBody: extractRequestBody(op),
+                    responseSchema: extractResponseSchema(op),
+                    responseDescription: extractResponseDescription(op),
+                });
+            }
+        }
+    }
+    return { info, baseUrl, authType, operations, componentSchemas };
+}
+/** Recursively resolve $ref pointers in-place */
+function resolveRefs(node, root) {
+    if (node === null || typeof node !== 'object')
+        return node;
+    if (Array.isArray(node)) {
+        for (let i = 0; i < node.length; i++) {
+            node[i] = resolveRefs(node[i], root);
+        }
+        return node;
+    }
+    if (typeof node.$ref === 'string') {
+        const resolved = resolveRefPath(node.$ref, root);
+        if (resolved && typeof resolved === 'object') {
+            // Merge any sibling properties (like description overrides)
+            const { $ref, ...siblings } = node;
+            const result = { ...resolved, ...siblings };
+            // Don't recurse infinitely — mark as resolved
+            return result;
+        }
+        return node;
+    }
+    for (const key of Object.keys(node)) {
+        node[key] = resolveRefs(node[key], root);
+    }
+    return node;
+}
+function resolveRefPath(ref, root) {
+    if (!ref.startsWith('#/'))
+        return undefined;
+    const parts = ref.slice(2).split('/');
+    let current = root;
+    for (const part of parts) {
+        const decoded = part.replace(/~1/g, '/').replace(/~0/g, '~');
+        if (current == null || typeof current !== 'object')
+            return undefined;
+        current = current[decoded];
+    }
+    return current;
+}
+function extractBaseUrl(doc) {
+    // OpenAPI 3.x
+    if (doc.servers && doc.servers.length > 0) {
+        return doc.servers[0].url ?? '';
+    }
+    // Swagger 2.x
+    if (doc.host) {
+        const scheme = doc.schemes?.[0] ?? 'https';
+        const basePath = doc.basePath ?? '';
+        return `${scheme}://${doc.host}${basePath}`;
+    }
+    return '';
+}
+function detectAuthType(doc) {
+    const securitySchemes = doc.components?.securitySchemes ?? doc.securityDefinitions ?? {};
+    for (const scheme of Object.values(securitySchemes)) {
+        if (scheme.type === 'oauth2')
+            return 'oauth2';
+        if (scheme.type === 'http' && scheme.scheme === 'bearer')
+            return 'bearer';
+        if (scheme.type === 'apiKey')
+            return 'apiKey';
+    }
+    return 'none';
+}
+function extractParams(params, location) {
+    return params
+        .filter((p) => p.in === location)
+        .map((p) => ({
+        name: p.name,
+        required: p.required ?? location === 'path',
+        schema: (p.schema ?? { type: 'string' }),
+        description: p.description,
+    }));
+}
+function extractRequestBody(op) {
+    const body = op.requestBody;
+    if (!body)
+        return undefined;
+    const content = body.content;
+    if (!content)
+        return undefined;
+    // Prefer JSON
+    const jsonContent = content['application/json'];
+    if (jsonContent?.schema)
+        return jsonContent.schema;
+    // Fallback to first content type
+    const firstKey = Object.keys(content)[0];
+    if (firstKey && content[firstKey]?.schema) {
+        return content[firstKey].schema;
+    }
+    return undefined;
+}
+function extractResponseDescription(op) {
+    const responses = op.responses;
+    if (!responses)
+        return undefined;
+    for (const code of ['200', '201', '202']) {
+        const resp = responses[code];
+        if (resp?.description)
+            return resp.description;
+    }
+    return undefined;
+}
+function extractResponseSchema(op) {
+    const responses = op.responses;
+    if (!responses)
+        return undefined;
+    // Look for 2xx responses in order of preference
+    for (const code of ['200', '201', '202', '204']) {
+        const resp = responses[code];
+        if (!resp)
+            continue;
+        const content = resp.content;
+        if (!content)
+            continue;
+        const jsonContent = content['application/json'];
+        if (jsonContent?.schema)
+            return jsonContent.schema;
+        const firstKey = Object.keys(content)[0];
+        if (firstKey && content[firstKey]?.schema) {
+            return content[firstKey].schema;
+        }
+    }
+    // Fallback: any 2xx
+    for (const [code, resp] of Object.entries(responses)) {
+        if (code.startsWith('2') && resp.content) {
+            const jsonContent = resp.content['application/json'];
+            if (jsonContent?.schema)
+                return jsonContent.schema;
+        }
+    }
+    return undefined;
+}

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

@@ -0,0 +1,53 @@
+/**
+ * Converts OpenAPI schemas into Zod code strings.
+ *
+ * Chaining order: base → refinements → .nullable() → .optional() → .default() → .describe()
+ */
+export interface OpenAPISchema {
+    type?: string;
+    format?: string;
+    description?: string;
+    enum?: unknown[];
+    items?: OpenAPISchema;
+    properties?: Record<string, OpenAPISchema>;
+    required?: string[];
+    nullable?: boolean;
+    default?: unknown;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    minItems?: number;
+    maxItems?: number;
+    oneOf?: OpenAPISchema[];
+    anyOf?: OpenAPISchema[];
+    allOf?: OpenAPISchema[];
+    additionalProperties?: boolean | OpenAPISchema;
+    $ref?: string;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+}
+export interface ZodCodegenContext {
+    /** Map from component schema name to its Zod variable name */
+    schemaRefs: Map<string, string>;
+    /** Track which refs are actually used */
+    usedRefs: Set<string>;
+    /** Indent level for readability */
+    indent: number;
+}
+export declare function createContext(schemaRefs?: Map<string, string>): ZodCodegenContext;
+/**
+ * Convert a single OpenAPI schema to a Zod expression string.
+ * Does NOT include .optional() — that's handled at the property level based on `required`.
+ */
+export declare function schemaToZod(schema: OpenAPISchema, ctx: ZodCodegenContext, opts?: {
+    optional?: boolean;
+}): string;
+/**
+ * Generate the Zod variable name for a component schema.
+ * e.g. "PaginatedResponse" → "PaginatedResponseSchema"
+ */
+export declare function schemaVarName(name: string): string;

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

@@ -0,0 +1,251 @@
+/**
+ * Converts OpenAPI schemas into Zod code strings.
+ *
+ * Chaining order: base → refinements → .nullable() → .optional() → .default() → .describe()
+ */
+export function createContext(schemaRefs) {
+    return {
+        schemaRefs: schemaRefs ?? new Map(),
+        usedRefs: new Set(),
+        indent: 0,
+    };
+}
+/**
+ * Convert a single OpenAPI schema to a Zod expression string.
+ * Does NOT include .optional() — that's handled at the property level based on `required`.
+ */
+export function schemaToZod(schema, ctx, opts = {}) {
+    let code = schemaToZodBase(schema, ctx);
+    // Refinements
+    code = applyRefinements(code, schema);
+    // Nullable
+    if (schema.nullable) {
+        code += '.nullable()';
+    }
+    // Optional
+    if (opts.optional) {
+        code += '.optional()';
+    }
+    // Default
+    if (schema.default !== undefined) {
+        code += `.default(${JSON.stringify(schema.default)})`;
+    }
+    // Description
+    if (schema.description) {
+        code += `.describe(${JSON.stringify(schema.description)})`;
+    }
+    return code;
+}
+function schemaToZodBase(schema, ctx) {
+    // Handle $ref
+    if (schema.$ref) {
+        const refName = schema.$ref.split('/').pop();
+        const zodName = ctx.schemaRefs.get(refName);
+        if (zodName) {
+            ctx.usedRefs.add(refName);
+            return zodName;
+        }
+        // Unknown ref — fallback to z.unknown()
+        return 'z.unknown()';
+    }
+    // Handle allOf — merge into single object
+    if (schema.allOf && schema.allOf.length > 0) {
+        return handleAllOf(schema.allOf, ctx);
+    }
+    // Handle oneOf/anyOf — union
+    if (schema.oneOf && schema.oneOf.length > 0) {
+        return handleUnion(schema.oneOf, ctx);
+    }
+    if (schema.anyOf && schema.anyOf.length > 0) {
+        return handleUnion(schema.anyOf, ctx);
+    }
+    // Handle enum
+    if (schema.enum && schema.enum.length > 0) {
+        return handleEnum(schema.enum);
+    }
+    // Handle by type
+    switch (schema.type) {
+        case 'string':
+            return handleString(schema);
+        case 'integer':
+            return 'z.number().int()';
+        case 'number':
+            return 'z.number()';
+        case 'boolean':
+            return 'z.boolean()';
+        case 'array':
+            return handleArray(schema, ctx);
+        case 'object':
+            return handleObject(schema, ctx);
+        default:
+            // No type specified but has properties — treat as object
+            if (schema.properties) {
+                return handleObject(schema, ctx);
+            }
+            return 'z.unknown()';
+    }
+}
+function handleString(schema) {
+    switch (schema.format) {
+        case 'uuid':
+            return 'z.string().uuid()';
+        case 'date-time':
+            return 'z.string().datetime()';
+        case 'date':
+            return 'z.string().date()';
+        case 'email':
+            return 'z.string().email()';
+        case 'uri':
+        case 'url':
+            return 'z.string().url()';
+        default:
+            return 'z.string()';
+    }
+}
+function handleEnum(values) {
+    // If all values are strings, use z.enum
+    if (values.every((v) => typeof v === 'string')) {
+        const enumValues = values.map((v) => JSON.stringify(v)).join(', ');
+        return `z.enum([${enumValues}])`;
+    }
+    // Mixed types — use z.union of z.literal
+    const literals = values.map((v) => `z.literal(${JSON.stringify(v)})`).join(', ');
+    return `z.union([${literals}])`;
+}
+function handleArray(schema, ctx) {
+    const itemsZod = schema.items
+        ? schemaToZodBase(schema.items, ctx)
+        : 'z.unknown()';
+    return `z.array(${itemsZod})`;
+}
+function indent(ctx) {
+    return '  '.repeat(ctx.indent);
+}
+function handleObject(schema, ctx) {
+    if (!schema.properties || Object.keys(schema.properties).length === 0) {
+        // Object with no defined properties
+        if (schema.additionalProperties) {
+            const valueSchema = typeof schema.additionalProperties === 'object'
+                ? schemaToZod(schema.additionalProperties, ctx)
+                : 'z.unknown()';
+            return `z.record(z.string(), ${valueSchema})`;
+        }
+        return 'z.record(z.string(), z.unknown())';
+    }
+    const inner = { ...ctx, indent: ctx.indent + 1 };
+    const pad = indent(inner);
+    const closePad = indent(ctx);
+    const requiredSet = new Set(schema.required ?? []);
+    const entries = [];
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+        const isOptional = !requiredSet.has(key);
+        const propZod = schemaToZod(propSchema, inner, { optional: isOptional });
+        entries.push(`${pad}${safeKey(key)}: ${propZod},`);
+    }
+    return `z.object({\n${entries.join('\n')}\n${closePad}})`;
+}
+function handleAllOf(schemas, ctx) {
+    // Collect all properties from all schemas
+    const mergedProps = {};
+    const mergedRequired = [];
+    for (const sub of schemas) {
+        if (sub.$ref) {
+            const refName = sub.$ref.split('/').pop();
+            const zodName = ctx.schemaRefs.get(refName);
+            if (zodName) {
+                ctx.usedRefs.add(refName);
+                // If it's a pure ref in an allOf, we'd need to merge/extend
+                // For simplicity, if we have refs mixed with objects, use .merge()
+            }
+        }
+        if (sub.properties) {
+            Object.assign(mergedProps, sub.properties);
+        }
+        if (sub.required) {
+            mergedRequired.push(...sub.required);
+        }
+    }
+    // If we have only refs, use .merge()
+    const refSchemas = schemas.filter((s) => s.$ref);
+    const objSchemas = schemas.filter((s) => !s.$ref && (s.properties || s.type === 'object'));
+    if (refSchemas.length > 0 && objSchemas.length === 0) {
+        const parts = refSchemas.map((s) => {
+            const refName = s.$ref.split('/').pop();
+            ctx.usedRefs.add(refName);
+            return ctx.schemaRefs.get(refName) || 'z.object({})';
+        });
+        if (parts.length === 1)
+            return parts[0];
+        return parts.reduce((acc, part) => `${acc}.merge(${part})`);
+    }
+    // Otherwise, merge into a single object
+    if (Object.keys(mergedProps).length > 0) {
+        return handleObject({
+            type: 'object',
+            properties: mergedProps,
+            required: [...new Set(mergedRequired)],
+        }, ctx);
+    }
+    // Fallback
+    return 'z.unknown()';
+}
+function handleUnion(schemas, ctx) {
+    const members = schemas.map((s) => schemaToZodBase(s, ctx));
+    if (members.length === 1)
+        return members[0];
+    return `z.union([${members.join(', ')}])`;
+}
+function applyRefinements(code, schema) {
+    let result = code;
+    // String refinements
+    if (schema.type === 'string' || (!schema.type && !schema.format)) {
+        if (schema.minLength !== undefined) {
+            result += `.min(${schema.minLength})`;
+        }
+        if (schema.maxLength !== undefined) {
+            result += `.max(${schema.maxLength})`;
+        }
+        if (schema.pattern) {
+            result += `.regex(new RegExp(${JSON.stringify(schema.pattern)}))`;
+        }
+    }
+    // Number refinements
+    if (schema.type === 'number' || schema.type === 'integer') {
+        if (schema.minimum !== undefined) {
+            result += `.min(${schema.minimum})`;
+        }
+        if (schema.maximum !== undefined) {
+            result += `.max(${schema.maximum})`;
+        }
+        if (schema.exclusiveMinimum !== undefined) {
+            result += `.gt(${schema.exclusiveMinimum})`;
+        }
+        if (schema.exclusiveMaximum !== undefined) {
+            result += `.lt(${schema.exclusiveMaximum})`;
+        }
+    }
+    // Array refinements
+    if (schema.type === 'array') {
+        if (schema.minItems !== undefined) {
+            result += `.min(${schema.minItems})`;
+        }
+        if (schema.maxItems !== undefined) {
+            result += `.max(${schema.maxItems})`;
+        }
+    }
+    return result;
+}
+/** Ensure property keys are safe identifiers, or quote them */
+function safeKey(key) {
+    if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)) {
+        return key;
+    }
+    return JSON.stringify(key);
+}
+/**
+ * Generate the Zod variable name for a component schema.
+ * e.g. "PaginatedResponse" → "PaginatedResponseSchema"
+ */
+export function schemaVarName(name) {
+    return name.endsWith('Schema') ? name : `${name}Schema`;
+}

package/dist/src/utils/pikku-cli-config.d.ts

@@ -1,4 +1,4 @@
-import { PikkuCLIConfig } from '../../types/config.js';
-import { CLILogger } from '../services/cli-logger.service.js';
+import type { PikkuCLIConfig } from '../../types/config.js';
+import type { CLILogger } from '../services/cli-logger.service.js';
 export declare const getPikkuCLIConfig: (logger: CLILogger, configFile: string | undefined, requiredFields: Array<keyof PikkuCLIConfig>, exitProcess?: boolean) => Promise<PikkuCLIConfig>;
 export declare const validateCLIConfig: (cliConfig: PikkuCLIConfig, required: Array<keyof PikkuCLIConfig>) => void;

package/dist/src/utils/pikku-cli-config.js

@@ -1,13 +1,13 @@
 import { join, dirname, resolve, isAbsolute } from 'path';
 import { readdir, readFile } from 'fs/promises';
-const CONFIG_DIR_FILES = [
-    'nextBackendFile',
-    'nextHTTPFile',
+const CLIENT_FILE_KEYS = [
     'fetchFile',
     'websocketFile',
     'rpcWiringsFile',
     'queueWiringsFile',
     'mcpJsonFile',
+    'nextBackendFile',
+    'nextHTTPFile',
 ];
 export const getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields, exitProcess = false) => {
     const config = await _getPikkuCLIConfig(logger, configFile, requiredFields, exitProcess);
@@ -38,10 +38,6 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
                     ...extendedConfig.packageMappings,
                     ...config.packageMappings,
                 },
-                externalPackages: {
-                    ...extendedConfig.externalPackages,
-                    ...config.externalPackages,
-                },
                 ignoreFiles: config.ignoreFiles ??
                     extendedConfig.ignoreFiles ?? [
                     '**/*.test.ts',
@@ -62,7 +58,6 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
                 ...config,
                 configDir,
                 packageMappings: config.packageMappings || {},
-                externalPackages: config.externalPackages || {},
                 rootDir: config.rootDir
                     ? resolve(configDir, config.rootDir)
                     : configDir,
@@ -126,6 +121,11 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.httpTypesFile) {
             result.httpTypesFile = join(httpDir, 'pikku-http-types.gen.ts');
         }
+        // Gateways
+        const gatewayDir = join(result.outDir, 'gateway');
+        if (!result.gatewaysWiringFile) {
+            result.gatewaysWiringFile = join(gatewayDir, 'pikku-gateway-wirings.gen.ts');
+        }
         // Channels/WebSocket
         if (!result.channelsWiringFile) {
             result.channelsWiringFile = join(channelDir, 'pikku-channels.gen.ts');
@@ -142,7 +142,7 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.channelsTypesFile) {
             result.channelsTypesFile = join(channelDir, 'pikku-channel-types.gen.ts');
         }
-        // RPC (internal and external)
+        // RPC (internal and addon)
         if (!result.rpcInternalWiringMetaFile) {
             result.rpcInternalWiringMetaFile = join(rpcDir, 'pikku-rpc-wirings-meta.internal.gen.ts');
         }
@@ -155,12 +155,31 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.rpcMapDeclarationFile) {
             result.rpcMapDeclarationFile = join(rpcDir, 'pikku-rpc-wirings-map.gen.d.ts');
         }
-        // RPC config defaults
-        if (!result.rpc) {
-            result.rpc = {};
-        }
-        if (!result.rpc.remoteRpcWorkersPath) {
-            result.rpc.remoteRpcWorkersPath = join(rpcDir, 'pikku-remote-rpc-workers.gen.ts');
+        // Remote RPC workers file (auto-derived)
+        if (!result.remoteRpcWorkersFile) {
+            result.remoteRpcWorkersFile = join(rpcDir, 'pikku-remote-rpc-workers.gen.ts');
+        }
+        // Derive feature file paths from scaffold.pikkuDir when enabled
+        if (result.scaffold?.rpc ||
+            result.scaffold?.agent ||
+            result.scaffold?.console ||
+            result.scaffold?.workflow) {
+            const pikkuDir = result.scaffold.pikkuDir ?? 'pikku';
+            const resolvedPikkuDir = isAbsolute(pikkuDir)
+                ? pikkuDir
+                : join(result.rootDir, pikkuDir);
+            if (result.scaffold.rpc && !result.publicRpcFile) {
+                result.publicRpcFile = join(resolvedPikkuDir, 'rpc.wiring.gen.ts');
+            }
+            if (result.scaffold.agent && !result.publicAgentFile) {
+                result.publicAgentFile = join(resolvedPikkuDir, 'agent.wiring.gen.ts');
+            }
+            if (result.scaffold.console && !result.consoleFunctionsFile) {
+                result.consoleFunctionsFile = join(resolvedPikkuDir, 'console.gen.ts');
+            }
+            if (result.scaffold.workflow && !result.workflowWorkersFile) {
+                result.workflowWorkersFile = join(resolvedPikkuDir, 'workflows.gen.ts');
+            }
         }
         const triggerDir = join(result.outDir, 'trigger');
         if (!result.triggersTypesFile) {
@@ -263,9 +282,6 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.mcpWiringsFile) {
             result.mcpWiringsFile = join(mcpDir, 'pikku-mcp-wirings.gen.ts');
         }
-        if (!result.mcpJsonFile) {
-            result.mcpJsonFile = join(mcpDir, 'pikku-mcp.gen.json');
-        }
         if (!result.mcpTypesFile) {
             result.mcpTypesFile = join(mcpDir, 'pikku-mcp-types.gen.ts');
         }
@@ -309,13 +325,12 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.nodeTypesFile) {
             result.nodeTypesFile = join(consoleDir, 'pikku-node-types.gen.ts');
         }
-        // External (for wireSecret, external service factories, and external meta)
-        const externalDir = join(result.outDir, 'external');
+        const addonDir = join(result.outDir, 'addon');
         if (!result.packageFile) {
-            result.packageFile = join(externalDir, 'pikku-package.gen.ts');
+            result.packageFile = join(addonDir, 'pikku-package.gen.ts');
         }
-        if (!result.externalTypesFile) {
-            result.externalTypesFile = join(externalDir, 'pikku-external-types.gen.ts');
+        if (!result.addonTypesFile) {
+            result.addonTypesFile = join(addonDir, 'pikku-addon-types.gen.ts');
         }
         // Secrets (typed wrapper for SecretService)
         const secretsDir = join(result.outDir, 'secrets');
@@ -346,21 +361,27 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
             if (objectKey.endsWith('File') ||
                 objectKey.endsWith('Directory') ||
                 objectKey.endsWith('Dir')) {
-                const relativeTo = CONFIG_DIR_FILES.includes(objectKey)
-                    ? result.configDir
-                    : result.rootDir;
                 // Only normalize string values to avoid corrupting nested objects
                 if (result[objectKey] && typeof result[objectKey] === 'string') {
                     if (!isAbsolute(result[objectKey])) {
-                        result[objectKey] = join(relativeTo, result[objectKey]);
+                        result[objectKey] = join(result.rootDir, result[objectKey]);
                     }
                 }
             }
         }
+        // Resolve clientFiles paths relative to configDir
+        if (result.clientFiles) {
+            for (const key of CLIENT_FILE_KEYS) {
+                const val = result.clientFiles[key];
+                if (val && typeof val === 'string' && !isAbsolute(val)) {
+                    result.clientFiles[key] = join(result.configDir, val);
+                }
+            }
+        }
         if (!isAbsolute(result.tsconfig)) {
             result.tsconfig = join(result.rootDir, result.tsconfig);
         }
-        if (result.externalPackage) {
+        if (result.addon) {
             const packageJsonPath = join(result.rootDir, 'package.json');
             try {
                 const packageJsonContent = await readFile(packageJsonPath, 'utf-8');
@@ -370,10 +391,10 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
                     packageJson.name.trim() === '') {
                     throw new Error(`package.json at ${packageJsonPath} is missing a valid "name" field`);
                 }
-                result.externalPackageName = packageJson.name;
+                result.addonName = packageJson.name;
             }
             catch (e) {
-                throw new Error(`externalPackage is true but could not read or parse package.json at ${packageJsonPath}: ${e.message}`);
+                throw new Error(`addon is true but could not read or parse package.json at ${packageJsonPath}: ${e.message}`);
             }
         }
         return result;

package/dist/src/utils/pikku-files-and-methods.d.ts

@@ -1,4 +1,4 @@
-import { InspectorState, InspectorOptions } from '@pikku/inspector';
+import type { InspectorState, InspectorOptions } from '@pikku/inspector';
 interface Meta {
     file: string;
     variable: string;

package/dist/src/utils/pikku-files-and-methods.js

@@ -1,4 +1,4 @@
-import { getFilesAndMethods, } from '@pikku/inspector';
+import { getFilesAndMethods } from '@pikku/inspector';
 /**
  * @deprecated Use state.filesAndMethods from InspectorState instead
  */