npm - @pikku/cli - Versions diffs - 0.12.156 → 0.12.160 - Mend

@@ -1,16 +1,43 @@
 import { pikkuSessionlessFunc } from '#pikku/function';
+import { existsSync, readdirSync, rmSync } from 'node:fs';
+import { dirname, join } from 'path';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { mcpSurfaceSlug } from '../../../utils/mcp-surface.js';
 import { serializeMCPJson } from '@pikku/inspector';
 export const pikkuMCPJSON = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const state = await getInspectorState();
         const mcpJsonFile = config.mcpJsonFile ?? config.clientFiles?.mcpJsonFile;
-        if (mcpJsonFile) {
-            const mcpJson = serializeMCPJson(logger, state);
-            await writeFileInDir(logger, mcpJsonFile, mcpJson, {
-                ignoreModifyComment: true,
-            });
+        if (!mcpJsonFile) {
+            return;
+        }
+        await writeFileInDir(logger, mcpJsonFile, serializeMCPJson(logger, state), {
+            ignoreModifyComment: true,
+        });
+        // A project serving several MCP endpoints gets one manifest per endpoint,
+        // named after its surface, beside the default one. `deploy-apply` finds
+        // each by the slug in its unit's name, so the slug has to be built the
+        // same way here as it is in the analyzer.
+        const mcpDir = dirname(mcpJsonFile);
+        const surfaces = state.mcpEndpoints.surfaces ?? {};
+        const written = new Set();
+        for (const surface of Object.keys(surfaces)) {
+            const name = `mcp.${mcpSurfaceSlug(surface)}.gen.json`;
+            written.add(name);
+            await writeFileInDir(logger, join(mcpDir, name), serializeMCPJson(logger, state, surface), { ignoreModifyComment: true });
+        }
+        // A surface that has gone away leaves its manifest behind, and `pikku dev`
+        // mounts every manifest it finds — so without this, dropping `mcpEndpoint`
+        // keeps serving the endpoint it was supposed to remove, with whatever tool
+        // list it had on the last run that still wrote it.
+        if (existsSync(mcpDir)) {
+            for (const name of readdirSync(mcpDir)) {
+                if (!/^mcp\..+\.gen\.json$/.test(name) || written.has(name))
+                    continue;
+                logger.debug(`Removing manifest for a surface that no longer exists: ${name}`);
+                rmSync(join(mcpDir, name));
+            }
         }
     },
     middleware: [

@@ -94,7 +94,9 @@ export declare const KnowledgePlanDeferOutputSchema: import("zod").ZodObject<{
     path: import("zod").ZodString;
     message: import("zod").ZodString;
 }, import("zod/v4/core").$strip>;
-export declare const KnowledgeReconcileInputSchema: import("zod").ZodObject<{}, import("zod/v4/core").$strip>;
+export declare const KnowledgeReconcileInputSchema: import("zod").ZodObject<{
+    require: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>;
 export declare const KnowledgeReconcileOutputSchema: import("zod").ZodObject<{
     kind: import("zod").ZodEnum<{
         "ask-user": "ask-user";
@@ -116,4 +118,6 @@ export declare const KnowledgeReconcileOutputSchema: import("zod").ZodObject<{
             description: import("zod").ZodOptional<import("zod").ZodString>;
         }, import("zod/v4/core").$strip>>>;
     }, import("zod/v4/core").$strip>>;
+    satisfied: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
 }, import("zod/v4/core").$strip>;

@@ -17,6 +17,7 @@ export const buildFeaturesMeta = (featureFiles) => {
             name: feature.name ?? id,
             ...(feature.description ? { description: feature.description } : {}),
             tags: feature.tags ?? [],
+            ...(feature.document === undefined ? {} : { document: feature.document }),
             entries: feature.entries.map((entry) => entry.data === undefined
                 ? { scenario: entry.scenario }
                 : { scenario: entry.scenario, data: entry.data }),

@@ -223,6 +223,12 @@ type PikkuFeatureConfig<Scenarios extends readonly unknown[]> = {
   name: string
   description?: string
   tags?: string[]
+  /**
+   * Whether this feature is guide material, defaulting to true. \`pikku scenario
+   * guide\` requires every documented feature to be cited by a page; a feature
+   * that is pure plumbing sets this false rather than being written about.
+   */
+  document?: boolean
   scenarios: { [K in keyof Scenarios]: PikkuFeatureEntry<Scenarios[K]> }
   /**
    * Runs ONCE before the whole group — not before each scenario. Per-scenario

@@ -27,6 +27,7 @@ export class BunServerRunner {
             // Read off this options object by the transport, not off `config` — so it
             // has to be forwarded here explicitly, exactly like the JWT above.
             mcpJson: options.mcpJson,
+            mcpSurfaces: options.mcpSurfaces,
         });
     }
 }

@@ -45,6 +45,19 @@ export type DevServerOptions = {
         resources?: unknown[];
         prompts?: unknown[];
     };
+    /**
+     * The further MCP endpoints this project serves, one per surface, each with
+     * the path it answers on. Forwarded the same way and with the same
+     * consequence for forgetting: the surface 404s with no error anywhere.
+     */
+    mcpSurfaces?: Array<{
+        mcpJson: {
+            tools?: unknown[];
+            resources?: unknown[];
+            prompts?: unknown[];
+        };
+        mcpPath: string;
+    }>;
 };
 export interface DevServerRunner {
     /**

@@ -383,6 +383,8 @@ export const createSingletonServices = async (config) => {
     // Keeping the check in this single place avoids `typeof Bun` branches leaking
     // into the deploy pipeline / dev command.
     const isBun = typeof globalThis.Bun !== 'undefined';
+    const deployBundler = config.deploy?.bundler ?? 'auto';
+    const bundleWithBun = deployBundler === 'bun' || (deployBundler === 'auto' && isBun);
     return {
         config,
         logger,
@@ -392,7 +394,7 @@ export const createSingletonServices = async (config) => {
         getInspectorState,
         invalidateInspectorState,
         workflowService,
-        bundler: isBun ? new BunBundler() : new NodeBundler(),
+        bundler: bundleWithBun ? new BunBundler() : new NodeBundler(),
         devServerRunner: isBun
             ? new BunServerRunner()
             : new NodeServerRunner(rootDir),

@@ -0,0 +1,8 @@
+/**
+ * The slug a surface's manifest filename and its deploy unit name are both
+ * built from. `deploy-apply` recovers the filename by stripping `mcp-` off the
+ * unit name, so codegen and the analyzer have to agree on it exactly or a
+ * deployed unit reads a manifest nobody wrote — hence one function, not the
+ * same expression written twice.
+ */
+export declare const mcpSurfaceSlug: (surface: string) => string;

@pikku/cli 0.12.156 → 0.12.160