@pikku/cli 0.9.15 → 0.10.0

package/dist/src/services/cli-logger.service.js

@@ -0,0 +1,77 @@
+import chalk from 'chalk';
+import { LogLevel } from '@pikku/core';
+const logo = `
+ ______ _ _     _
+(_____ (_) |   | |
+ _____) )| |  _| |  _ _   _
+|  ____/ | |_/ ) |_/ ) | | |
+| |    | |  _ (|  _ (|  _ (| |_| |
+|_|    |_|_| _)_| _)____/
+`;
+const BASE_ERROR_URL = 'https://pikku.dev/errors';
+export class CLILogger {
+    silent;
+    level = LogLevel.info;
+    criticalErrors = [];
+    constructor({ logLogo, silent = false, }) {
+        this.silent = silent;
+        if (logLogo && !silent) {
+            this.logPikkuLogo();
+        }
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    info(message) {
+        if (this.level > LogLevel.info || this.silent)
+            return;
+        let c = chalk.blue;
+        if (typeof message === 'object') {
+            if (message.type === 'success') {
+                c = chalk.green;
+            }
+            else if (message.type === 'timing') {
+                c = chalk.gray;
+            }
+        }
+        console.log(c(typeof message === 'string' ? message : message.message));
+    }
+    error(message) {
+        if (this.level > LogLevel.error)
+            return;
+        console.error(chalk.red(message));
+    }
+    warn(message) {
+        if (this.level > LogLevel.warn)
+            return;
+        console.error(chalk.yellow(message));
+    }
+    debug(message) {
+        if (this.level > LogLevel.debug || this.silent)
+            return;
+        console.log(chalk.gray(message));
+    }
+    critical(code, message) {
+        const url = `${BASE_ERROR_URL}/${code.toLowerCase()}`;
+        const formattedMessage = `[${code}] ${message}\n  → ${url}`;
+        this.criticalErrors.push(formattedMessage);
+        console.error(chalk.red.bold(formattedMessage));
+    }
+    hasCriticalErrors() {
+        return this.criticalErrors.length > 0;
+    }
+    logPikkuLogo() {
+        this.primary(logo);
+        // // When running from dist/, __filename is dist/src/services/cli-logger.service.js
+        // // So we need to go up 3 levels: dist/src/services -> dist/src -> dist -> package.json
+        // const packageJson = JSON.parse(
+        //   readFileSync(`${dirname(__filename)}/../../../package.json`, 'utf-8')
+        // )
+        // this.primary(`⚙️  Welcome to the Pikku CLI (v${packageJson.version})\n`)
+    }
+    primary(message) {
+        if (!this.silent) {
+            console.log(chalk.green(message));
+        }
+    }
+}

package/dist/src/services.d.ts

@@ -0,0 +1,20 @@
+import type { Config, Services, SingletonServices, UserSession } from '../types/application-types.js';
+import { CreateConfig, CreateSessionServices, CreateSingletonServices } from '@pikku/core';
+import { PikkuCLIConfig } from '../types/config.js';
+import { ForwardedLogMessage } from './services/cli-logger-forwarder.service.js';
+/**
+ * Default CLI renderer that logs output using the logger
+ */
+export declare const defaultCLIRenderer: import("@pikku/core").CorePikkuCLIRender<ForwardedLogMessage, SingletonServices, import("@pikku/core").CoreUserSession>;
+/**
+ * Client-safe CLI renderer that outputs to console (no service dependencies)
+ * This renderer can be used in CLI-over-channel clients
+ */
+export declare const clientCLIRenderer: import("@pikku/core").CorePikkuCLIRender<ForwardedLogMessage, import("@pikku/core").CoreServices, import("@pikku/core").CoreUserSession>;
+export declare const createConfig: CreateConfig<Config, [PikkuCLIConfig]>;
+/**
+ * Singleton services factory for the Pikku CLI
+ * This function creates the singleton services used by the CLI and is created once on start.
+ */
+export declare const createSingletonServices: CreateSingletonServices<Config, SingletonServices>;
+export declare const createSessionServices: CreateSessionServices<SingletonServices, Services, UserSession>;

package/dist/src/services.js

@@ -0,0 +1,162 @@
+import { pikkuCLIRender } from '@pikku/core/cli';
+import { LocalVariablesService } from '@pikku/core/services';
+import { CLILogger } from './services/cli-logger.service.js';
+import { getPikkuCLIConfig } from './utils/pikku-cli-config.js';
+import { inspect, serializeInspectorState, deserializeInspectorState, filterInspectorState, } from '@pikku/inspector';
+import { glob } from 'tinyglobby';
+import path from 'path';
+import { CLILoggerForwarder, } from './services/cli-logger-forwarder.service.js';
+import { readFile, writeFile } from 'fs/promises';
+const logger = new CLILogger({ logLogo: true, silent: false });
+/**
+ * Parse a comma-separated string or array into an array of trimmed, non-empty strings
+ * Returns undefined if the input is empty/undefined or results in an empty array
+ */
+function parseCommaSeparated(value) {
+    if (!value)
+        return undefined;
+    // If already an array, flatten and split any comma-separated values
+    if (Array.isArray(value)) {
+        const flattened = value
+            .flatMap((item) => item.split(','))
+            .map((item) => item.trim())
+            .filter((item) => item.length > 0);
+        return flattened.length > 0 ? flattened : undefined;
+    }
+    // If string, split by comma
+    const parsed = value
+        .split(',')
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+    return parsed.length > 0 ? parsed : undefined;
+}
+/**
+ * Parse CLI filter arguments into InspectorFilters format
+ */
+function parseCLIFilters(data) {
+    const filters = {};
+    if (data.filters) {
+        return JSON.parse(data.filters);
+    }
+    // Parse each filter type from CLI arguments
+    const names = parseCommaSeparated(data.names);
+    const tags = parseCommaSeparated(data.tags);
+    const types = parseCommaSeparated(data.types);
+    const directories = parseCommaSeparated(data.directories);
+    const httpRoutes = parseCommaSeparated(data.httpRoutes);
+    const httpMethods = parseCommaSeparated(data.httpMethods);
+    // Only include non-undefined values in the result
+    if (names)
+        filters.names = names;
+    if (tags)
+        filters.tags = tags;
+    if (types)
+        filters.types = types;
+    if (directories)
+        filters.directories = directories;
+    if (httpRoutes)
+        filters.httpRoutes = httpRoutes;
+    if (httpMethods)
+        filters.httpMethods = httpMethods;
+    return filters;
+}
+/**
+ * Default CLI renderer that logs output using the logger
+ */
+export const defaultCLIRenderer = pikkuCLIRender((_services, data) => {
+    if (data) {
+        logger[data.level]({ message: data.message, type: data.type });
+    }
+});
+/**
+ * Client-safe CLI renderer that outputs to console (no service dependencies)
+ * This renderer can be used in CLI-over-channel clients
+ */
+export const clientCLIRenderer = pikkuCLIRender((_services, data) => {
+    if (data) {
+        // Simple console output without service dependencies
+        const prefix = data.type ? `[${data.type}] ` : '';
+        console.log(`${prefix}${data.message}`);
+    }
+});
+export const createConfig = async (_variablesService, data) => {
+    const cliConfig = await getPikkuCLIConfig(logger, data.configFile, [], true);
+    // Load inspector state from file if stateInput is provided
+    let preloadedInspectorState = undefined;
+    if (data.stateInput) {
+        try {
+            logger.info(`Loading inspector state from ${data.stateInput}`);
+            const stateJson = await readFile(data.stateInput, 'utf-8');
+            const serializedState = JSON.parse(stateJson);
+            preloadedInspectorState = deserializeInspectorState(serializedState);
+            logger.info(`Inspector state loaded successfully`);
+        }
+        catch (error) {
+            logger.error(`Failed to load inspector state from ${data.stateInput}: ${error.message}`);
+            throw error;
+        }
+    }
+    return {
+        ...cliConfig,
+        ...data,
+        filters: parseCLIFilters(data),
+        preloadedInspectorState,
+    };
+};
+/**
+ * Singleton services factory for the Pikku CLI
+ * This function creates the singleton services used by the CLI and is created once on start.
+ */
+export const createSingletonServices = async (config) => {
+    const { rootDir, srcDirectories, filters, preloadedInspectorState, stateOutput, } = config;
+    const variables = new LocalVariablesService();
+    // Store unfiltered state
+    let unfilteredState = preloadedInspectorState;
+    const getInspectorState = async (refresh = false) => {
+        // Get or refresh the unfiltered state
+        if (!unfilteredState || refresh) {
+            // Run inspector WITHOUT filters to get full state
+            const wiringFiles = (await Promise.all(srcDirectories.map((dir) => glob(`${path.join(rootDir, dir)}/**/*.ts`)))).flat();
+            unfilteredState = await inspect(logger, wiringFiles, {
+                // NO filters here - inspector returns full unfiltered state
+                types: {
+                    configFileType: config.configFile,
+                    userSessionType: config.userSessionType,
+                    singletonServicesFactoryType: config.singletonServicesFactoryType,
+                    sessionServicesFactoryType: config.sessionServicesFactoryType,
+                },
+            });
+            // Save unfiltered inspector state to file if stateOutput is provided
+            if (stateOutput && 'typesLookup' in unfilteredState) {
+                try {
+                    logger.info(`Saving inspector state to ${stateOutput}`);
+                    const serialized = serializeInspectorState(unfilteredState);
+                    await writeFile(stateOutput, JSON.stringify(serialized, null, 2), 'utf-8');
+                    logger.info(`Inspector state saved successfully`);
+                }
+                catch (error) {
+                    logger.error(`Failed to save inspector state to ${stateOutput}: ${error.message}`);
+                    // Don't throw - state saving is optional/nice-to-have
+                }
+            }
+        }
+        // Apply filters as a post-processing step
+        const filteredState = filterInspectorState(unfilteredState, filters, logger);
+        return filteredState;
+    };
+    return {
+        config,
+        logger,
+        variables,
+        getInspectorState,
+    };
+};
+export const createSessionServices = async ({ logger }, { cli, channel }) => {
+    const vChannel = cli ? cli.channel : channel;
+    if (!vChannel) {
+        throw new Error('No channel provided for CLI services');
+    }
+    return {
+        logger: new CLILoggerForwarder(logger, vChannel),
+    };
+};

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

@@ -0,0 +1,10 @@
+import { FilesAndMethodsErrors } from '@pikku/inspector';
+export type RequiredTypes = Partial<{
+    config: boolean;
+    sessionServiceType: boolean;
+    singletonServicesType: boolean;
+    userSessionType: boolean;
+    singletonServicesFactory: boolean;
+    sessionServicesFactory: boolean;
+}>;
+export declare const checkRequiredTypes: (errors: FilesAndMethodsErrors, requires?: RequiredTypes) => void;

package/dist/src/utils/check-required-types.js

@@ -0,0 +1,31 @@
+export const checkRequiredTypes = (errors, requires = {}) => {
+    // Only throw if there are errors AND we require those types
+    const hasRequiredErrors = Array.from(errors.keys()).some((message) => {
+        if (requires.config && message.includes('CoreConfig'))
+            return true;
+        if (requires.sessionServiceType && message.includes('CoreServices'))
+            return true;
+        if (requires.singletonServicesType &&
+            message.includes('CoreSingletonServices'))
+            return true;
+        if (requires.userSessionType && message.includes('CoreUserSession'))
+            return true;
+        if (requires.singletonServicesFactory &&
+            message.includes('CreateSingletonServices'))
+            return true;
+        if (requires.sessionServicesFactory &&
+            message.includes('CreateSessionServices'))
+            return true;
+        return false;
+    });
+    if (hasRequiredErrors) {
+        const result = ['Found errors:'];
+        errors.forEach((filesAndMethods, message) => {
+            result.push(`- ${message}`);
+            filesAndMethods.forEach((methods, file) => {
+                result.push(`\t* methods: ${methods.map(({ variable, type }) => `${variable}: ${type}`).join(', ')}`);
+            });
+        });
+        throw new Error(result.join('\n'));
+    }
+};

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

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

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

@@ -0,0 +1,43 @@
+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/file-import-path.d.ts

@@ -0,0 +1 @@
+export declare const getFileImportRelativePath: (from: string, to: string, packageMappings: Record<string, string>) => string;

package/dist/src/utils/file-import-path.js

@@ -0,0 +1,43 @@
+import { relative, dirname, resolve } from 'path';
+export const getFileImportRelativePath = (from, to, packageMappings) => {
+    let filePath = relative(dirname(from), to);
+    if (!/^\.+\//.test(filePath)) {
+        filePath = `./${filePath}`;
+    }
+    // If the path includes node_modules, strip everything before and including node_modules/
+    if (filePath.includes('node_modules')) {
+        const nodeModulesIndex = filePath.indexOf('node_modules/');
+        if (nodeModulesIndex !== -1) {
+            filePath = filePath.substring(nodeModulesIndex + 'node_modules/'.length);
+        }
+        return filePath.replace('.ts', '.js');
+    }
+    const absolutePath = resolve(dirname(from), to);
+    const fromAbsolutePath = resolve(dirname(from));
+    // Check if both files are in the same package directory
+    // If so, skip packageMappings to use relative paths
+    let inSamePackage = false;
+    for (const [path] of Object.entries(packageMappings)) {
+        if (absolutePath.includes(path) && fromAbsolutePath.includes(path)) {
+            inSamePackage = true;
+            break;
+        }
+    }
+    // Only apply packageMappings if files are not in the same package
+    if (!inSamePackage) {
+        // let usesPackageName = false
+        for (const [path, packageName] of Object.entries(packageMappings)) {
+            if (absolutePath.includes(path)) {
+                // usesPackageName = true
+                // Use string slicing instead of regex to avoid ReDoS and ensure correct behavior
+                const pathIndex = absolutePath.indexOf(path);
+                filePath = packageName + absolutePath.slice(pathIndex + path.length);
+                break;
+            }
+        }
+    }
+    // if (usesPackageName) {
+    //   return filePath.replace('.ts', '')
+    // }
+    return filePath.replace('.ts', '.js');
+};

package/dist/src/utils/file-imports-serializer.d.ts

@@ -0,0 +1 @@
+export declare const serializeFileImports: (importType: string, outputPath: string, files: Set<string>, packageMappings?: Record<string, string>) => string;

package/dist/src/utils/file-imports-serializer.js

@@ -0,0 +1,13 @@
+import { getFileImportRelativePath } from './file-import-path.js';
+export const serializeFileImports = (importType, outputPath, files, packageMappings = {}) => {
+    const serializedOutput = [
+        `/* The files with an ${importType} function call */`,
+    ];
+    Array.from(files)
+        .sort()
+        .forEach((path) => {
+        const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
+        serializedOutput.push(`import '${filePath}'`);
+    });
+    return serializedOutput.join('\n');
+};

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

@@ -0,0 +1,9 @@
+import { CLILogger } from '../services/cli-logger.service.js';
+export declare const DO_NOT_MODIFY_COMMENT: string;
+export declare const writeFileInDir: (logger: CLILogger, path: string, content: string, { ignoreModifyComment, logWrite, }?: {
+    ignoreModifyComment?: boolean;
+    logWrite?: boolean;
+}) => Promise<void>;
+export declare const removeFileInDir: (logger: CLILogger, path: string, { logRemove }?: {
+    logRemove?: boolean;
+}) => Promise<void>;

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

@@ -0,0 +1,50 @@
+import { dirname } from 'path';
+import { mkdir, readFile, writeFile, rm } from 'fs/promises';
+import { existsSync } from 'fs';
+import { getCLIVersion } from './get-cli-version.js';
+export const DO_NOT_MODIFY_COMMENT = `/**
+ * This file was generated by @pikku/cli@${getCLIVersion()}
+ */
+`;
+export const writeFileInDir = async (logger, path, content, { ignoreModifyComment = false, logWrite = true, } = {}) => {
+    if (path.includes('.json')) {
+        ignoreModifyComment = true;
+    }
+    if (content.includes('server-only')) {
+        content = content.replace("'server-only'", `'server-only'\n\n${ignoreModifyComment ? '' : DO_NOT_MODIFY_COMMENT}`);
+    }
+    else {
+        content = `${ignoreModifyComment ? '' : DO_NOT_MODIFY_COMMENT}${content}`;
+    }
+    // Try to read existing file content
+    let existingContent;
+    try {
+        existingContent = await readFile(path, 'utf-8');
+    }
+    catch (error) {
+        // Only suppress ENOENT (file not found) errors
+        // Rethrow permission, I/O, encoding, or other errors
+        const nodeError = error;
+        if (nodeError.code !== 'ENOENT') {
+            throw error;
+        }
+        // File doesn't exist, so we need to write it
+    }
+    // Only write if content has changed or file doesn't exist
+    if (existingContent !== content) {
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, content, 'utf-8');
+        if (logWrite) {
+            logger.info({ message: `✓ File written to ${path}`, type: 'success' });
+        }
+    }
+};
+export const removeFileInDir = async (logger, path, { logRemove = true } = {}) => {
+    // Check if file exists before attempting removal
+    if (existsSync(path)) {
+        await rm(path, { force: true });
+        if (logRemove) {
+            logger.info({ message: `✓ File removed at ${path}`, type: 'success' });
+        }
+    }
+};

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

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

package/dist/src/utils/generate-bootstrap-file.js

@@ -0,0 +1,21 @@
+import { getFileImportRelativePath } from './file-import-path.js';
+import { writeFileInDir } from './file-writer.js';
+export const generateBootstrapFile = async (logger, config, bootstrapFile, specificImports, schemas, hasMiddleware) => {
+    // Common imports that every bootstrap file needs
+    const commonImports = [];
+    // Add middleware first (must be registered before functions meta)
+    if (hasMiddleware) {
+        commonImports.push(config.middlewareFile);
+    }
+    commonImports.push(config.functionsMetaMinFile, config.functionsFile);
+    // Add schema if it exists
+    if (schemas) {
+        commonImports.push(`${config.schemaDirectory}/register.gen.ts`);
+    }
+    // Combine common imports with specific imports
+    const allImports = [...commonImports, ...specificImports];
+    await writeFileInDir(logger, bootstrapFile, allImports
+        .map((to) => `import '${getFileImportRelativePath(bootstrapFile, to, config.packageMappings)}'`)
+        .sort((to) => (to.includes('meta') ? -1 : 1)) // Ensure meta files are at the top
+        .join('\n'));
+};

package/dist/src/utils/get-cli-version.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns the CLI version string
+ * Works from both src/ and dist/src/ locations
+ */
+export declare const getCLIVersion: () => string;

package/dist/src/utils/get-cli-version.js

@@ -0,0 +1,27 @@
+import { dirname, join } from 'path';
+import { readFile } from 'fs/promises';
+import { fileURLToPath } from 'url';
+// Get package version for generated file comments
+const __dirname = dirname(fileURLToPath(import.meta.url));
+let version = 'unknown';
+try {
+    // Try from src/ first (development), then from dist/src/ (built)
+    const pkgPath = join(__dirname, '..', '..', 'package.json');
+    const pkgJson = JSON.parse(await readFile(pkgPath, 'utf-8'));
+    version = pkgJson.version;
+}
+catch {
+    try {
+        const pkgPath = join(__dirname, '..', '..', '..', 'package.json');
+        const pkgJson = JSON.parse(await readFile(pkgPath, 'utf-8'));
+        version = pkgJson.version;
+    }
+    catch {
+        // Fallback to unknown if package.json can't be found
+    }
+}
+/**
+ * Returns the CLI version string
+ * Works from both src/ and dist/src/ locations
+ */
+export const getCLIVersion = () => version;

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

@@ -0,0 +1,4 @@
+import { PikkuCLIConfig } from '../../types/config.js';
+import { 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;