@pikku/cli 0.12.0 → 0.12.1

package/dist/.pikku/workflow/pikku-workflow-wirings.gen.d.ts

@@ -1,4 +1,4 @@
 export {};
 /**
- * This file was generated by @pikku/cli@0.12.0
+ * This file was generated by @pikku/cli@0.12.1
  */

package/dist/.pikku/workflow/pikku-workflow-wirings.gen.js

@@ -1,4 +1,4 @@
 export {};
 /**
- * This file was generated by @pikku/cli@0.12.0
+ * This file was generated by @pikku/cli@0.12.1
  */

package/dist/src/cli.wiring.js

@@ -12,6 +12,13 @@ import { watch } from './functions/commands/watch.js';
 import { consoleCommand } from './functions/commands/console.js';
 import { pikkuVersionsInit } from './functions/commands/versions-init.js';
 import { pikkuVersionsCheck } from './functions/commands/versions-check.js';
+import { pikkuVersionsUpdate } from './functions/commands/versions-update.js';
+import { pikkuNewFunction } from './functions/commands/new-function.js';
+import { pikkuNewWiring } from './functions/commands/new-wiring.js';
+import { pikkuNewMiddleware } from './functions/commands/new-middleware.js';
+import { pikkuNewPermission } from './functions/commands/new-permission.js';
+import { pikkuNewAddon } from './functions/commands/new-addon.js';
+import { pikkuInfoFunctions, pikkuInfoTags, pikkuInfoMiddleware, pikkuInfoPermissions, } from './functions/commands/info.js';
 // import { clientCLIRenderer } from './services.js'
 wireCLI({
     program: 'pikku',
@@ -119,18 +126,192 @@ wireCLI({
             func: pikkuNext,
             description: 'Generate Next.js backend and HTTP wrappers',
         }),
-        init: pikkuCLICommand({
-            func: pikkuVersionsInit,
-            description: 'Initialize project',
+        new: {
+            description: 'Scaffold new functions and wirings',
+            subcommands: {
+                function: pikkuCLICommand({
+                    func: pikkuNewFunction,
+                    description: 'Create a new Pikku function file',
+                    parameters: '<name>',
+                    options: {
+                        type: {
+                            description: 'Function type: func, sessionless (default), or void',
+                            short: 't',
+                            default: 'sessionless',
+                        },
+                    },
+                }),
+                wiring: pikkuCLICommand({
+                    func: pikkuNewWiring,
+                    description: 'Create a new wiring file',
+                    parameters: '<name>',
+                    options: {
+                        type: {
+                            description: 'Wiring type: http (default), channel, scheduler, queue, mcp, cli, or trigger',
+                            short: 't',
+                            default: 'http',
+                        },
+                    },
+                }),
+                middleware: pikkuCLICommand({
+                    func: pikkuNewMiddleware,
+                    description: 'Create a new middleware file',
+                    parameters: '<name>',
+                    options: {
+                        type: {
+                            description: 'Middleware type: simple (default) or factory',
+                            short: 't',
+                            default: 'simple',
+                        },
+                    },
+                }),
+                permission: pikkuCLICommand({
+                    func: pikkuNewPermission,
+                    description: 'Create a new permission file',
+                    parameters: '<name>',
+                    options: {
+                        type: {
+                            description: 'Permission type: simple (default) or factory',
+                            short: 't',
+                            default: 'simple',
+                        },
+                    },
+                }),
+                addon: pikkuCLICommand({
+                    func: pikkuNewAddon,
+                    description: 'Scaffold a new addon package',
+                    parameters: '<name>',
+                    options: {
+                        displayName: {
+                            description: 'Human-readable display name (defaults to PascalCase of name)',
+                        },
+                        description: {
+                            description: 'Package description (defaults to "{displayName} integration for Pikku")',
+                        },
+                        category: {
+                            description: 'Forge category (defaults to "General")',
+                            default: 'General',
+                        },
+                        dir: {
+                            description: 'Override output directory (defaults to scaffold.addonDir or cwd)',
+                            short: 'd',
+                        },
+                        secret: {
+                            description: 'Include secret schema file',
+                            default: false,
+                        },
+                        variable: {
+                            description: 'Include variable definition file',
+                            default: false,
+                        },
+                        oauth: {
+                            description: 'Include OAuth2 credential wiring and OAuth2Client-based API service',
+                            default: false,
+                        },
+                        test: {
+                            description: 'Include test harness (default: true)',
+                            default: true,
+                        },
+                        openapi: {
+                            description: 'Path to OpenAPI YAML/JSON spec to generate functions from',
+                        },
+                    },
+                }),
+            },
+        },
+        versions: {
+            description: 'Manage function contract versions',
+            subcommands: {
+                init: pikkuCLICommand({
+                    func: pikkuVersionsInit,
+                    description: 'Initialize the version manifest (versions.json)',
+                    options: {
+                        force: {
+                            description: 'Overwrite existing manifest',
+                        },
+                    },
+                }),
+                check: pikkuCLICommand({
+                    func: pikkuVersionsCheck,
+                    description: 'Validate function contracts against the version manifest',
+                }),
+                update: pikkuCLICommand({
+                    func: pikkuVersionsUpdate,
+                    description: 'Update the version manifest with current contract hashes',
+                }),
+            },
+        },
+        info: pikkuCLICommand({
+            func: pikkuInfoFunctions,
+            description: 'Show information about Pikku project resources',
             options: {
-                force: {
-                    description: 'Overwrite existing manifest',
+                limit: {
+                    description: 'Maximum number of rows to display',
+                    default: '50',
+                },
+                verbose: {
+                    description: 'Show additional details (file paths, services, etc.)',
+                    default: false,
                 },
             },
-        }),
-        'versions-check': pikkuCLICommand({
-            func: pikkuVersionsCheck,
-            description: 'Validate function contracts against the version manifest',
+            subcommands: {
+                functions: pikkuCLICommand({
+                    func: pikkuInfoFunctions,
+                    description: 'List all registered functions',
+                    options: {
+                        limit: {
+                            description: 'Maximum number of rows to display',
+                            default: '50',
+                        },
+                        verbose: {
+                            description: 'Show additional details (type, middleware, file)',
+                            default: false,
+                        },
+                    },
+                }),
+                tags: pikkuCLICommand({
+                    func: pikkuInfoTags,
+                    description: 'List all tags with associated functions, middleware, and permissions',
+                    options: {
+                        limit: {
+                            description: 'Maximum number of rows to display',
+                            default: '50',
+                        },
+                        verbose: {
+                            description: 'Show names instead of counts',
+                            default: false,
+                        },
+                    },
+                }),
+                middleware: pikkuCLICommand({
+                    func: pikkuInfoMiddleware,
+                    description: 'List all middleware definitions',
+                    options: {
+                        limit: {
+                            description: 'Maximum number of rows to display',
+                            default: '50',
+                        },
+                        verbose: {
+                            description: 'Show additional details (sourceFile, services)',
+                            default: false,
+                        },
+                    },
+                }),
+                permissions: pikkuCLICommand({
+                    func: pikkuInfoPermissions,
+                    description: 'List all permission definitions',
+                    options: {
+                        limit: {
+                            description: 'Maximum number of rows to display',
+                            default: '50',
+                        },
+                        verbose: {
+                            description: 'Show additional details (sourceFile, services)',
+                            default: false,
+                        },
+                    },
+                }),
+            },
         }),
     },
 });

package/dist/src/functions/commands/all.js

@@ -16,7 +16,7 @@ export const all = pikkuVoidFunc({
         await rpc.invoke('pikkuFunctionTypesSplit', null);
         await rpc.invoke('pikkuTriggerTypes', null);
         await rpc.invoke('pikkuAIAgentTypes', null);
-        if (!config.externalPackage) {
+        if (!config.addon) {
             await rpc.invoke('pikkuHTTPTypes', null);
             await rpc.invoke('pikkuChannelTypes', null);
             await rpc.invoke('pikkuSchedulerTypes', null);
@@ -53,11 +53,11 @@ export const all = pikkuVoidFunc({
         await rpc.invoke('pikkuSecrets', null);
         await rpc.invoke('pikkuVariableDefinitionTypes', null);
         await rpc.invoke('pikkuVariables', null);
-        await rpc.invoke('pikkuExternalTypes', null);
+        await rpc.invoke('pikkuAddonTypes', null);
         if (hasInternalRPCs) {
             allImports.push(config.rpcInternalWiringMetaFile);
         }
-        if (agents || !config.externalPackage) {
+        if (agents || !config.addon) {
             await getInspectorState(true);
         }
         const schemas = await rpc.invoke('pikkuSchemas', null);
@@ -66,7 +66,7 @@ export const all = pikkuVoidFunc({
         }
         await rpc.invoke('pikkuRPCInternalMap', null);
         await rpc.invoke('pikkuRPCExposedMap', null);
-        if (!config.externalPackage) {
+        if (!config.addon) {
             const http = await rpc.invoke('pikkuHTTP', null);
             if (http) {
                 await rpc.invoke('pikkuHTTPMap', null);
@@ -84,7 +84,7 @@ export const all = pikkuVoidFunc({
         }
         const workflows = await rpc.invoke('pikkuWorkflow', null);
         let remoteRPC = false;
-        if (!config.externalPackage) {
+        if (!config.addon) {
             remoteRPC = await rpc.invoke('pikkuRemoteRPC', null);
         }
         if (workflows || remoteRPC) {
@@ -99,7 +99,7 @@ export const all = pikkuVoidFunc({
         if (workflows) {
             allImports.push(config.workflowsWiringFile);
         }
-        if (!config.externalPackage) {
+        if (!config.addon) {
             const queues = await rpc.invoke('pikkuQueue', null);
             if (queues) {
                 await rpc.invoke('pikkuQueueMap', null);

package/dist/src/functions/commands/info.d.ts

@@ -0,0 +1,9 @@
+type InfoInput = {
+    limit?: string;
+    verbose?: boolean;
+};
+export declare const pikkuInfoFunctions: import("#pikku").PikkuFunctionConfig<InfoInput, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<InfoInput, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuInfoTags: import("#pikku").PikkuFunctionConfig<InfoInput, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<InfoInput, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuInfoMiddleware: import("#pikku").PikkuFunctionConfig<InfoInput, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<InfoInput, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuInfoPermissions: import("#pikku").PikkuFunctionConfig<InfoInput, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<InfoInput, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export {};

package/dist/src/functions/commands/info.js

@@ -0,0 +1,283 @@
+import path from 'path';
+import { pikkuSessionlessFunc } from '#pikku';
+const printTable = (headers, rows, limit) => {
+    const all = [headers, ...rows.slice(0, limit)];
+    const widths = headers.map((_, col) => Math.max(...all.map((row) => (row[col] ?? '').length)));
+    const line = (row) => row.map((cell, i) => cell.padEnd(widths[i])).join('  ');
+    console.log(line(headers));
+    console.log(widths.map((w) => '-'.repeat(w)).join('  '));
+    for (const row of rows.slice(0, limit)) {
+        console.log(line(row));
+    }
+    if (rows.length > limit) {
+        console.log(`... and ${rows.length - limit} more (use --limit to show more)`);
+    }
+};
+const getFunctionTypes = (funcId, state) => {
+    const types = [];
+    if (state.http?.meta) {
+        for (const routes of Object.values(state.http.meta)) {
+            for (const meta of Object.values(routes)) {
+                if (meta.pikkuFuncId === funcId)
+                    types.push('http');
+            }
+        }
+    }
+    if (state.channels?.meta) {
+        for (const channel of Object.values(state.channels.meta)) {
+            const messages = [channel.connect, channel.disconnect, channel.message];
+            for (const msg of messages) {
+                if (msg && msg.pikkuFuncId === funcId)
+                    types.push('channel');
+            }
+        }
+    }
+    if (state.scheduledTasks?.meta) {
+        if (funcId in state.scheduledTasks.meta)
+            types.push('scheduler');
+    }
+    if (state.queueWorkers?.meta) {
+        if (funcId in state.queueWorkers.meta)
+            types.push('queue');
+    }
+    if (state.workflows?.meta) {
+        if (funcId in state.workflows.meta)
+            types.push('workflow');
+    }
+    if (state.mcpEndpoints?.toolsMeta) {
+        if (funcId in state.mcpEndpoints.toolsMeta)
+            types.push('mcp');
+    }
+    if (state.cli?.meta) {
+        for (const program of Object.values(state.cli.meta)) {
+            if (program.commands) {
+                for (const cmd of program.commands) {
+                    if (cmd.pikkuFuncId === funcId)
+                        types.push('cli');
+                }
+            }
+        }
+    }
+    if (state.triggers?.meta) {
+        if (funcId in state.triggers.meta)
+            types.push('trigger');
+    }
+    return [...new Set(types)];
+};
+const getFilePath = (funcId, state) => {
+    const entry = state.functions.files.get(funcId);
+    if (entry) {
+        return path.relative(state.rootDir, entry.path);
+    }
+    return '';
+};
+const formatMetadata = (meta) => {
+    if (!meta || meta.length === 0)
+        return '';
+    return meta
+        .map((m) => {
+        if ('name' in m)
+            return m.name;
+        if ('type' in m)
+            return m.type;
+        return '?';
+    })
+        .join(', ');
+};
+export const pikkuInfoFunctions = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }, data) => {
+        const limit = parseInt(data?.limit ?? '50', 10);
+        const verbose = !!data?.verbose;
+        const state = await getInspectorState();
+        const meta = state.functions.meta;
+        const entries = Object.entries(meta);
+        if (entries.length === 0) {
+            console.log('No functions found.');
+            return;
+        }
+        if (!verbose) {
+            const headers = ['pikkuFuncId', 'name', 'tags'];
+            const rows = entries.map(([id, m]) => [
+                id,
+                m.name ?? '',
+                (m.tags ?? []).join(', '),
+            ]);
+            printTable(headers, rows, limit);
+        }
+        else {
+            const headers = [
+                'pikkuFuncId',
+                'name',
+                'tags',
+                'type',
+                'middleware',
+                'permissions',
+                'file',
+            ];
+            const rows = entries.map(([id, m]) => [
+                id,
+                m.name ?? '',
+                (m.tags ?? []).join(', '),
+                getFunctionTypes(id, state).join(', '),
+                formatMetadata(m.middleware),
+                formatMetadata(m.permissions),
+                getFilePath(id, state),
+            ]);
+            printTable(headers, rows, limit);
+        }
+    },
+});
+export const pikkuInfoTags = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }, data) => {
+        const limit = parseInt(data?.limit ?? '50', 10);
+        const verbose = !!data?.verbose;
+        const state = await getInspectorState();
+        const meta = state.functions.meta;
+        const tagMap = new Map();
+        for (const [id, m] of Object.entries(meta)) {
+            for (const tag of m.tags ?? []) {
+                if (!tagMap.has(tag)) {
+                    tagMap.set(tag, {
+                        funcIds: [],
+                        middlewareNames: [],
+                        permissionNames: [],
+                    });
+                }
+                tagMap.get(tag).funcIds.push(m.name ?? id);
+            }
+        }
+        const tagMiddleware = state.middleware?.tagMiddleware;
+        if (tagMiddleware) {
+            for (const [tag, group] of tagMiddleware) {
+                if (!tagMap.has(tag)) {
+                    tagMap.set(tag, {
+                        funcIds: [],
+                        middlewareNames: [],
+                        permissionNames: [],
+                    });
+                }
+                tagMap.get(tag).middlewareNames.push(...(group.instanceIds ?? []));
+            }
+        }
+        const tagPermissions = state.permissions?.tagPermissions;
+        if (tagPermissions) {
+            for (const [tag, group] of tagPermissions) {
+                if (!tagMap.has(tag)) {
+                    tagMap.set(tag, {
+                        funcIds: [],
+                        middlewareNames: [],
+                        permissionNames: [],
+                    });
+                }
+                tagMap.get(tag).permissionNames.push(...(group.instanceIds ?? []));
+            }
+        }
+        const tags = [...tagMap.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+        if (tags.length === 0) {
+            console.log('No tags found.');
+            return;
+        }
+        if (!verbose) {
+            const headers = ['tag', 'functions', 'middleware', 'permissions'];
+            const rows = tags.map(([tag, info]) => [
+                tag,
+                String(info.funcIds.length),
+                String(info.middlewareNames.length),
+                String(info.permissionNames.length),
+            ]);
+            printTable(headers, rows, limit);
+        }
+        else {
+            const headers = ['tag', 'functions', 'middleware', 'permissions'];
+            const rows = tags.map(([tag, info]) => [
+                tag,
+                info.funcIds.join(', ') || '(none)',
+                info.middlewareNames.join(', ') || '(none)',
+                info.permissionNames.join(', ') || '(none)',
+            ]);
+            printTable(headers, rows, limit);
+        }
+    },
+});
+export const pikkuInfoMiddleware = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }, data) => {
+        const limit = parseInt(data?.limit ?? '50', 10);
+        const verbose = !!data?.verbose;
+        const state = await getInspectorState();
+        const definitions = state.middleware?.definitions ?? {};
+        const entries = Object.entries(definitions);
+        if (entries.length === 0) {
+            console.log('No middleware found.');
+            return;
+        }
+        if (!verbose) {
+            const headers = ['id', 'name', 'exportedName'];
+            const rows = entries.map(([id, def]) => [
+                id,
+                def.name ?? '',
+                def.exportedName ?? '',
+            ]);
+            printTable(headers, rows, limit);
+        }
+        else {
+            const headers = [
+                'id',
+                'name',
+                'exportedName',
+                'sourceFile',
+                'services',
+                'description',
+            ];
+            const rows = entries.map(([id, def]) => [
+                id,
+                def.name ?? '',
+                def.exportedName ?? '',
+                def.sourceFile?.replace(state.rootDir + '/', '') ?? '',
+                def.services?.services?.join(', ') ?? '',
+                def.description ?? '',
+            ]);
+            printTable(headers, rows, limit);
+        }
+    },
+});
+export const pikkuInfoPermissions = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }, data) => {
+        const limit = parseInt(data?.limit ?? '50', 10);
+        const verbose = !!data?.verbose;
+        const state = await getInspectorState();
+        const definitions = state.permissions?.definitions ?? {};
+        const entries = Object.entries(definitions);
+        if (entries.length === 0) {
+            console.log('No permissions found.');
+            return;
+        }
+        if (!verbose) {
+            const headers = ['id', 'name', 'exportedName'];
+            const rows = entries.map(([id, def]) => [
+                id,
+                def.name ?? '',
+                def.exportedName ?? '',
+            ]);
+            printTable(headers, rows, limit);
+        }
+        else {
+            const headers = [
+                'id',
+                'name',
+                'exportedName',
+                'sourceFile',
+                'services',
+                'description',
+            ];
+            const rows = entries.map(([id, def]) => [
+                id,
+                def.name ?? '',
+                def.exportedName ?? '',
+                def.sourceFile?.replace(state.rootDir + '/', '') ?? '',
+                def.services?.services?.join(', ') ?? '',
+                def.description ?? '',
+            ]);
+            printTable(headers, rows, limit);
+        }
+    },
+});

package/dist/src/functions/commands/new-addon.d.ts

@@ -0,0 +1,34 @@
+export declare const pikkuNewAddon: import("#pikku").PikkuFunctionConfig<{
+    name: string;
+    displayName?: string;
+    description?: string;
+    category?: string;
+    dir?: string;
+    secret?: boolean;
+    variable?: boolean;
+    oauth?: boolean;
+    test?: boolean;
+    openapi?: string;
+}, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
+    name: string;
+    displayName?: string;
+    description?: string;
+    category?: string;
+    dir?: string;
+    secret?: boolean;
+    variable?: boolean;
+    oauth?: boolean;
+    test?: boolean;
+    openapi?: string;
+}, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    name: string;
+    displayName?: string;
+    description?: string;
+    category?: string;
+    dir?: string;
+    secret?: boolean;
+    variable?: boolean;
+    oauth?: boolean;
+    test?: boolean;
+    openapi?: string;
+}, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;