@pikku/cli 0.12.20 → 0.12.22

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

@@ -0,0 +1,454 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { getSchema } from '@pikku/core/schema';
+function out(value) {
+    console.log(JSON.stringify(value));
+}
+export const pikkuMetaFunctionsList = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }) => {
+        const state = await getInspectorState();
+        const meta = state.functions.meta ?? {};
+        const functions = Object.entries(meta).map(([id, m]) => ({
+            id,
+            name: m.name ?? id,
+            description: m.description ?? null,
+            tags: m.tags ?? [],
+        }));
+        out({ functions });
+    },
+});
+export const pikkuMetaFunctionsGet = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }, data) => {
+        const state = await getInspectorState();
+        const m = state.functions.meta?.[data.functionId];
+        if (!m)
+            throw new Error(`Function not found: ${data.functionId}`);
+        out({
+            functionId: data.functionId,
+            name: m.name ?? data.functionId,
+            description: m.description ?? null,
+            sourceFile: m.sourceFile ?? null,
+            inputSchemaName: m.inputSchemaName ?? null,
+            outputSchemaName: m.outputSchemaName ?? null,
+            tags: m.tags ?? [],
+            expose: m.expose === true,
+            readonly: m.readonly === true,
+            input: { name: m.inputSchemaName ?? null, jsonSchema: null },
+            output: { name: m.outputSchemaName ?? null, jsonSchema: null },
+        });
+    },
+});
+export const pikkuMetaSchemasList = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }) => {
+        const state = await getInspectorState();
+        const schemaNames = Object.keys(state.schemas ?? {}).sort();
+        out({ schemaNames });
+    },
+});
+export const pikkuMetaSchemasGet = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }, data) => {
+        const state = await getInspectorState();
+        const schema = state.schemas?.[data.schemaName] ?? getSchema(data.schemaName);
+        if (!schema)
+            throw new Error(`Schema not found: ${data.schemaName}`);
+        out({
+            schemaName: data.schemaName,
+            jsonSchema: schema,
+        });
+    },
+});
+export const pikkuMetaWorkflowsList = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }) => {
+        const state = await getInspectorState();
+        const meta = state.workflows?.meta ?? {};
+        const workflows = Object.entries(meta).map(([id, wf]) => ({
+            id,
+            name: wf.name ?? id,
+            description: wf.description ?? null,
+        }));
+        out({ workflows });
+    },
+});
+export const pikkuMetaWorkflowsGet = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }, data) => {
+        const state = await getInspectorState();
+        const wf = (state.workflows?.meta ?? {})[data.workflowId];
+        if (!wf)
+            throw new Error(`Workflow not found: ${data.workflowId}`);
+        out({
+            workflowId: data.workflowId,
+            name: wf.name ?? data.workflowId,
+            description: wf.description ?? null,
+            steps: wf.steps ?? [],
+            mode: wf.inline ? 'inline' : 'distributed',
+        });
+    },
+});
+export const pikkuMetaMiddlewareList = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }) => {
+        const state = await getInspectorState();
+        const defs = state.middleware?.definitions ?? {};
+        const middleware = Object.entries(defs).map(([id, d]) => ({
+            id,
+            name: d.name ?? id,
+            description: d.description ?? null,
+        }));
+        out({ middleware });
+    },
+});
+export const pikkuMetaMiddlewareGet = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }, data) => {
+        const state = await getInspectorState();
+        const d = (state.middleware?.definitions ?? {})[data.middlewareId];
+        if (!d)
+            throw new Error(`Middleware not found: ${data.middlewareId}`);
+        out({
+            middlewareId: data.middlewareId,
+            name: d.name ?? data.middlewareId,
+            description: d.description ?? null,
+            scope: ['function', 'workflow', 'agent'],
+            configSchema: null,
+        });
+    },
+});
+export const pikkuMetaPermissionsList = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }) => {
+        const state = await getInspectorState();
+        const defs = state.permissions?.definitions ?? {};
+        const permissions = Object.entries(defs).map(([id, d]) => ({
+            id,
+            name: d.name ?? id,
+            description: d.description ?? null,
+        }));
+        out({ permissions });
+    },
+});
+export const pikkuMetaPermissionsGet = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }, data) => {
+        const state = await getInspectorState();
+        const d = (state.permissions?.definitions ?? {})[data.permissionId];
+        if (!d)
+            throw new Error(`Permission not found: ${data.permissionId}`);
+        out({
+            permissionId: data.permissionId,
+            name: d.name ?? data.permissionId,
+            description: d.description ?? null,
+            scope: ['function', 'workflow', 'agent'],
+            configSchema: null,
+        });
+    },
+});
+export const pikkuMetaWiresList = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }) => {
+        const state = await getInspectorState();
+        const wireTypes = [
+            {
+                type: 'http',
+                count: Object.keys(state.http?.meta ?? {}).reduce((n, k) => n + Object.keys((state.http?.meta)[k] ?? {}).length, 0),
+            },
+            {
+                type: 'scheduler',
+                count: Object.keys(state.scheduledTasks?.meta ?? {}).length,
+            },
+            {
+                type: 'queue',
+                count: Object.keys(state.queueWorkers?.meta ?? {}).length,
+            },
+            {
+                type: 'channel',
+                count: Object.keys(state.channels?.meta ?? {}).length,
+            },
+            {
+                type: 'trigger',
+                count: Object.keys(state.triggers?.meta ?? {}).length,
+            },
+        ];
+        out({ wireTypes });
+    },
+});
+async function wiresByType(getInspectorState, type) {
+    const state = await getInspectorState();
+    let items = [];
+    if (type === 'http') {
+        const meta = state.http?.meta ?? {};
+        for (const [route, methods] of Object.entries(meta)) {
+            for (const [method, m] of Object.entries(methods ?? {})) {
+                items.push({
+                    id: `${method}:${route}`,
+                    functionId: m.pikkuFuncId,
+                    route,
+                    method,
+                });
+            }
+        }
+    }
+    else if (type === 'scheduler') {
+        items = Object.entries(state.scheduledTasks?.meta ?? {}).map(([functionId, m]) => ({
+            id: m?.name ?? functionId,
+            functionId,
+            cron: m?.schedule ?? null,
+        }));
+    }
+    else if (type === 'queue') {
+        items = Object.entries(state.queueWorkers?.meta ?? {}).map(([functionId, m]) => ({
+            id: m?.queueName ?? functionId,
+            functionId,
+            queueName: m?.queueName ?? null,
+        }));
+    }
+    else if (type === 'channel') {
+        items = Object.entries(state.channels?.meta ?? {}).map(([channelName, m]) => ({
+            id: channelName,
+            functionId: m?.message?.pikkuFuncId ??
+                m?.connect?.pikkuFuncId ??
+                m?.disconnect?.pikkuFuncId ??
+                null,
+            channelName,
+        }));
+    }
+    else if (type === 'trigger') {
+        items = Object.entries(state.triggers?.meta ?? {}).map(([functionId, m]) => ({
+            id: m?.name ?? functionId,
+            functionId,
+            eventType: m?.type ?? null,
+        }));
+    }
+    else {
+        throw new Error(`Unsupported wire type: ${type}`);
+    }
+    return items;
+}
+export const pikkuMetaWiresType = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }, data) => {
+        const items = await wiresByType(getInspectorState, data.type);
+        out({ type: data.type, items });
+    },
+});
+export const pikkuMetaWiresHttp = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }) => {
+        out({
+            type: 'http',
+            items: await wiresByType(getInspectorState, 'http'),
+        });
+    },
+});
+export const pikkuMetaWiresScheduler = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }) => {
+        out({
+            type: 'scheduler',
+            items: await wiresByType(getInspectorState, 'scheduler'),
+        });
+    },
+});
+export const pikkuMetaWiresQueue = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }) => {
+        out({
+            type: 'queue',
+            items: await wiresByType(getInspectorState, 'queue'),
+        });
+    },
+});
+export const pikkuMetaWiresChannel = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }) => {
+        out({
+            type: 'channel',
+            items: await wiresByType(getInspectorState, 'channel'),
+        });
+    },
+});
+export const pikkuMetaWiresTrigger = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }) => {
+        out({
+            type: 'trigger',
+            items: await wiresByType(getInspectorState, 'trigger'),
+        });
+    },
+});
+/**
+ * Bulk context endpoint.
+ *
+ * Single inspection → returns everything a planner needs for first-pass
+ * planning: functions, all wires, middleware, permissions, workflows, plus
+ * project capabilities (which wire types are in use) and layout (where new
+ * files should land). Designed to replace the 6+ list calls in the planner
+ * spec — one process spawn, one inspect, ~all the metadata.
+ *
+ * Targeted `pikku meta * get` calls are still the right tool when the planner
+ * wants schema details (input/output JSON schemas) for a specific entry.
+ */
+export const pikkuMetaContext = pikkuSessionlessFunc({
+    func: async ({ getInspectorState, config }) => {
+        const state = await getInspectorState();
+        const functions = Object.entries(state.functions.meta ?? {}).map(([id, m]) => ({
+            id,
+            name: m?.name ?? id,
+            description: m?.description ?? null,
+            tags: m?.tags ?? [],
+            sourceFile: m?.sourceFile ?? null,
+            inputSchemaName: m?.inputSchemaName ?? null,
+            outputSchemaName: m?.outputSchemaName ?? null,
+            expose: m?.expose === true,
+            readonly: m?.readonly === true,
+        }));
+        const middleware = Object.entries(state.middleware?.definitions ?? {}).map(([id, d]) => ({
+            id,
+            name: d?.name ?? id,
+            description: d?.description ?? null,
+        }));
+        const permissions = Object.entries(state.permissions?.definitions ?? {}).map(([id, d]) => ({
+            id,
+            name: d?.name ?? id,
+            description: d?.description ?? null,
+        }));
+        const workflows = Object.entries(state.workflows?.meta ?? {}).map(([id, wf]) => ({
+            id,
+            name: wf?.name ?? id,
+            description: wf?.description ?? null,
+            mode: wf?.inline ? 'inline' : 'distributed',
+        }));
+        const wires = {
+            http: await wiresByType(getInspectorState, 'http'),
+            scheduler: await wiresByType(getInspectorState, 'scheduler'),
+            queue: await wiresByType(getInspectorState, 'queue'),
+            channel: await wiresByType(getInspectorState, 'channel'),
+            trigger: await wiresByType(getInspectorState, 'trigger'),
+        };
+        const capabilities = {
+            http: wires.http.length > 0,
+            scheduler: wires.scheduler.length > 0,
+            queue: wires.queue.length > 0,
+            channel: wires.channel.length > 0,
+            trigger: wires.trigger.length > 0,
+            workflow: workflows.length > 0,
+            mcp: Object.keys(state.mcp?.meta ?? {}).length > 0,
+            agent: Object.keys(state.agents?.meta ?? {}).length > 0,
+        };
+        const cfg = config;
+        const srcDirectories = cfg.srcDirectories ?? [];
+        // If the project doesn't declare scaffold dirs, fall back to standard
+        // conventions rooted at the first src directory. Agents need a concrete
+        // target dir to emit `targetFile` against — null is not actionable.
+        const srcRoot = srcDirectories[0] ?? 'src';
+        const layout = {
+            rootDir: cfg.rootDir ?? null,
+            srcDirectories,
+            configFile: cfg.configFile ?? null,
+            scaffold: {
+                functionDir: cfg.scaffold?.functionDir ?? `${srcRoot}/functions`,
+                wiringDir: cfg.scaffold?.wiringDir ?? `${srcRoot}/wirings`,
+                middlewareDir: cfg.scaffold?.middlewareDir ?? `${srcRoot}/middleware`,
+                permissionDir: cfg.scaffold?.permissionDir ?? `${srcRoot}/permissions`,
+            },
+            globalHTTPPrefix: cfg.globalHTTPPrefix || null,
+        };
+        const summary = {
+            functions: functions.length,
+            middleware: middleware.length,
+            permissions: permissions.length,
+            workflows: workflows.length,
+            wires: {
+                http: wires.http.length,
+                scheduler: wires.scheduler.length,
+                queue: wires.queue.length,
+                channel: wires.channel.length,
+                trigger: wires.trigger.length,
+            },
+        };
+        out({
+            schemaVersion: 'meta-context.v1',
+            summary,
+            capabilities,
+            layout,
+            functions,
+            middleware,
+            permissions,
+            workflows,
+            wires,
+        });
+    },
+});
+/**
+ * Frontend-targeted metadata.
+ *
+ * Returns only what a UI agent needs to write client code:
+ *   - RPCs: every exposed function with input/output type names,
+ *     description, readonly flag, tags.
+ *   - Workflows: name, description, mode (inline|distributed), input/output
+ *     types resolved through the workflow's underlying function.
+ *   - Channels: name, route, description, plus the input/output types of
+ *     the connect / disconnect / message handlers and any routed messages.
+ *
+ * Everything else (middleware, permissions, layout, scaffold dirs,
+ * non-exposed functions, http wires) is a backend concern and stays in
+ * `pikku meta context`.
+ */
+export const pikkuMetaClients = pikkuSessionlessFunc({
+    func: async ({ getInspectorState }) => {
+        const state = await getInspectorState();
+        const functionsMeta = (state.functions.meta ?? {});
+        const lookupIO = (pikkuFuncId) => {
+            if (!pikkuFuncId)
+                return { input: null, output: null, description: null };
+            const m = functionsMeta[pikkuFuncId];
+            return {
+                input: m?.inputSchemaName ?? null,
+                output: m?.outputSchemaName ?? null,
+                description: m?.description ?? null,
+            };
+        };
+        const rpcs = Object.entries(functionsMeta)
+            .filter(([_id, m]) => m?.expose === true)
+            .map(([id, m]) => ({
+            name: id,
+            description: m?.description ?? null,
+            readonly: m?.readonly === true,
+            tags: m?.tags ?? [],
+            input: m?.inputSchemaName ?? null,
+            output: m?.outputSchemaName ?? null,
+        }));
+        const workflows = Object.entries(state.workflows?.meta ?? {}).map(([id, wf]) => {
+            const io = lookupIO(wf?.pikkuFuncId ?? id);
+            return {
+                name: id,
+                description: wf?.description ?? io.description,
+                mode: wf?.inline ? 'inline' : 'distributed',
+                input: io.input,
+                output: io.output,
+            };
+        });
+        const channels = Object.entries(state.channels?.meta ?? {}).map(([name, ch]) => {
+            const messageWirings = {};
+            for (const [route, methods] of Object.entries(ch?.messageWirings ?? {})) {
+                messageWirings[route] = {};
+                for (const [method, handler] of Object.entries(methods ?? {})) {
+                    messageWirings[route][method] = lookupIO(handler?.pikkuFuncId);
+                }
+            }
+            return {
+                name,
+                route: ch?.route ?? null,
+                description: ch?.description ?? null,
+                connect: ch?.connect?.pikkuFuncId
+                    ? lookupIO(ch.connect.pikkuFuncId)
+                    : null,
+                disconnect: ch?.disconnect?.pikkuFuncId
+                    ? lookupIO(ch.disconnect.pikkuFuncId)
+                    : null,
+                message: ch?.message?.pikkuFuncId
+                    ? lookupIO(ch.message.pikkuFuncId)
+                    : null,
+                messageWirings: Object.keys(messageWirings).length > 0 ? messageWirings : null,
+            };
+        });
+        out({
+            schemaVersion: 'meta-clients.v1',
+            summary: {
+                rpcs: rpcs.length,
+                workflows: workflows.length,
+                channels: channels.length,
+            },
+            rpcs,
+            workflows,
+            channels,
+        });
+    },
+});

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

@@ -12,7 +12,7 @@ export declare const pikkuNewAddon: import("#pikku").PikkuFunctionConfig<{
     openapi?: string;
     mcp?: boolean;
     camelCase?: boolean;
-}, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     name: string;
     displayName?: string;
     description?: string;
@@ -26,7 +26,7 @@ export declare const pikkuNewAddon: import("#pikku").PikkuFunctionConfig<{
     openapi?: string;
     mcp?: boolean;
     camelCase?: boolean;
-}, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
     name: string;
     displayName?: string;
     description?: string;
@@ -40,4 +40,4 @@ export declare const pikkuNewAddon: import("#pikku").PikkuFunctionConfig<{
     openapi?: string;
     mcp?: boolean;
     camelCase?: boolean;
-}, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

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

@@ -1,10 +1,10 @@
 export declare const pikkuNewFunction: import("#pikku").PikkuFunctionConfig<{
     name: string;
     type?: string;
-}, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     name: string;
     type?: string;
-}, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
     name: string;
     type?: string;
-}, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

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

@@ -1,10 +1,10 @@
 export declare const pikkuNewMiddleware: import("#pikku").PikkuFunctionConfig<{
     name: string;
     type?: string;
-}, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     name: string;
     type?: string;
-}, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
     name: string;
     type?: string;
-}, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

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

@@ -1,10 +1,10 @@
 export declare const pikkuNewPermission: import("#pikku").PikkuFunctionConfig<{
     name: string;
     type?: string;
-}, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     name: string;
     type?: string;
-}, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
     name: string;
     type?: string;
-}, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

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

@@ -1,10 +1,10 @@
 export declare const pikkuNewWiring: import("#pikku").PikkuFunctionConfig<{
     name: string;
     type?: string;
-}, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     name: string;
     type?: string;
-}, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
     name: string;
     type?: string;
-}, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/pikku-command-bootstrap.d.ts

@@ -1,4 +1,4 @@
 export type BootstrapInput = {
     allImports: string[];
 };
-export declare const pikkuBootstrap: import("#pikku").PikkuFunctionConfig<BootstrapInput, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<BootstrapInput, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<BootstrapInput, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuBootstrap: import("#pikku").PikkuFunctionConfig<BootstrapInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<BootstrapInput, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<BootstrapInput, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/pikku-command-bootstrap.js

@@ -1,3 +1,4 @@
+import { existsSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { pikkuSessionlessFunc } from '#pikku';
 import { getFileImportRelativePath } from '../../utils/file-import-path.js';
@@ -12,7 +13,20 @@ export const pikkuBootstrap = pikkuSessionlessFunc({
             logger.debug(`• Addon bootstrap: ${decl.package}`);
         }
         const wireAddonFileImports = Array.from(stateBeforeBootstrap.rpc?.wireAddonFiles ?? []).map((to) => `import '${getFileImportRelativePath(config.bootstrapFile, to, config.packageMappings)}'`);
-        const localImports = allImports.map((to) => `import '${getFileImportRelativePath(config.bootstrapFile, to, config.packageMappings)}'`);
+        const localImportTargets = Array.from(new Set([
+            ...(config.rpcInternalWiringMetaFile &&
+                existsSync(config.rpcInternalWiringMetaFile)
+                ? [config.rpcInternalWiringMetaFile]
+                : []),
+            ...allImports,
+        ]));
+        const safeLocalImportTargets = localImportTargets.filter((to) => {
+            if (typeof to === 'string' && to.length > 0)
+                return true;
+            logger.warn(`Skipping invalid bootstrap import path: ${String(to)}`);
+            return false;
+        });
+        const localImports = safeLocalImportTargets.map((to) => `import '${getFileImportRelativePath(config.bootstrapFile, to, config.packageMappings)}'`);
         const addonImports = addonBootstraps.map((packagePath) => `import '${packagePath}'`);
         const outDir = dirname(config.bootstrapFile);
         const metaServiceFile = join(outDir, 'pikku-meta-service.gen.ts');

package/dist/src/functions/commands/pikku-command-summary.d.ts

@@ -1 +1 @@
-export declare const pikkuSummary: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuSummary: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/pikku-command-summary.js

@@ -49,7 +49,13 @@ export const pikkuSummary = pikkuSessionlessFunc({
                 summary.set('workflowGraphs', workflowGraphsCount);
         }
         if (!logger.isSilent()) {
-            console.log(summary.format());
+            // Route through the logger so JSON mode emits a single NDJSON
+            // record instead of raw chalk-coloured text written directly to
+            // stdout (which would break NDJSON consumers).
+            logger.info({ message: summary.format(), type: 'summary' });
+        }
+        if (logger.hasCriticalErrors()) {
+            throw new Error('Pikku inspection failed due to critical diagnostics');
         }
     },
 });

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

@@ -0,0 +1,26 @@
+export declare const pikkuSkillsList: import("#pikku").PikkuFunctionConfig<{
+    target?: string;
+}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+    target?: string;
+}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    target?: string;
+}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuSkillsInstall: import("#pikku").PikkuFunctionConfig<{
+    agent?: string;
+    only?: string;
+    core?: boolean;
+    fabric?: boolean;
+    update?: boolean;
+}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+    agent?: string;
+    only?: string;
+    core?: boolean;
+    fabric?: boolean;
+    update?: boolean;
+}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    agent?: string;
+    only?: string;
+    core?: boolean;
+    fabric?: boolean;
+    update?: boolean;
+}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;