@pikku/cli 0.12.136 → 0.12.141

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

@@ -37,6 +37,9 @@ export const enableEvents = pikkuVoidFunc({
 export const enableRemoteRpc = pikkuVoidFunc({
     func: async ({ logger, config }) => enableFeature('remoteRpc', logger, config),
 });
+export const enableRemoteJobs = pikkuVoidFunc({
+    func: async ({ logger, config }) => enableFeature('remoteJobs', logger, config),
+});
 export const enableWebhook = pikkuVoidFunc({
     func: async ({ logger, config }) => enableFeature('webhook', logger, config),
 });

package/dist/src/functions/commands/knowledge-reconcile.d.ts

@@ -0,0 +1,45 @@
+import { renderKnowledgeReconcile } from '../knowledge/render.js';
+export declare const knowledgeReconcile: import("#pikku/function").PikkuFunctionConfig<Record<string, never>, {
+    kind: "hold" | "idle" | "repair-note" | "write-plan" | "ask-user" | "dispatch";
+    reason: string;
+    note?: string | undefined;
+    hold?: string | undefined;
+    notes?: string[] | undefined;
+    question?: {
+        header: string;
+        question: string;
+        options: {
+            label: string;
+            description?: string | undefined;
+        }[];
+    } | undefined;
+}, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<Record<string, never>, {
+    kind: "hold" | "idle" | "repair-note" | "write-plan" | "ask-user" | "dispatch";
+    reason: string;
+    note?: string | undefined;
+    hold?: string | undefined;
+    notes?: string[] | undefined;
+    question?: {
+        header: string;
+        question: string;
+        options: {
+            label: string;
+            description?: string | undefined;
+        }[];
+    } | undefined;
+}, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<Record<string, never>, {
+    kind: "hold" | "idle" | "repair-note" | "write-plan" | "ask-user" | "dispatch";
+    reason: string;
+    note?: string | undefined;
+    hold?: string | undefined;
+    notes?: string[] | undefined;
+    question?: {
+        header: string;
+        question: string;
+        options: {
+            label: string;
+            description?: string | undefined;
+        }[];
+    } | undefined;
+}, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export { renderKnowledgeReconcile };

package/dist/src/functions/commands/knowledge-reconcile.js

@@ -0,0 +1,11 @@
+import { pikkuSessionlessFunc } from '#pikku/function';
+import { runKnowledgeReconcile } from '@pikku/knowledge';
+import { renderKnowledgeReconcile } from '../knowledge/render.js';
+import { KnowledgeReconcileInputSchema, KnowledgeReconcileOutputSchema, } from '../knowledge/schemas.js';
+export const knowledgeReconcile = pikkuSessionlessFunc({
+    description: 'Say the one thing to do next with the knowledge base — repair a note, write a plan, ask the user, dispatch a build, or nothing — derived from what is on disk rather than from what a previous step remembered to announce.',
+    input: KnowledgeReconcileInputSchema,
+    output: KnowledgeReconcileOutputSchema,
+    func: async ({ config }) => runKnowledgeReconcile(config.rootDir),
+});
+export { renderKnowledgeReconcile };

package/dist/src/functions/db/local-db.d.ts

@@ -74,8 +74,6 @@ export declare function resolveDb(userConfig: UserConfigShape, rootDir: string,
     defaultSchema?: string;
     pgliteExtensions?: string[];
 } | string): ResolvedDb | null;
-/** @deprecated Use resolveDb(userConfig, ...) instead. */
-export declare function resolveLocalDb(sqliteDb: string | undefined, rootDir: string, outDir: string, runtimeDir?: string): ResolvedSqliteDb | null;
 /**
  * What an embedded PGlite instance needs beyond its data directory: where to
  * resolve extension packages from, and which ones to load.
@@ -356,6 +354,18 @@ export interface AddonDeclaration {
  * projects on either engine.
  */
 export declare function exportSchema(rootDir: string, pgliteExtensions?: string[]): Promise<SchemaArtifact>;
+/**
+ * Write the artifact a consumer reads, whether or not this package has tables.
+ *
+ * An addon with no tables still publishes, because the consumer's only other
+ * reading of an absent file is "this package cannot say", which it must treat
+ * as a broken publish. The empty artifact is the addon stating, in a file that
+ * ships, that it needs nothing.
+ */
+export declare function writeSchemaArtifact(rootDir: string, outDir: string, pgliteExtensions?: string[]): Promise<{
+    file: string;
+    dialects: string[];
+}>;
 /**
  * The schema every wired addon publishes, as sources.
  *

package/dist/src/functions/db/local-db.js

@@ -10,7 +10,7 @@ import { applyPikkuSchemas, compilePikkuSchemas, pikkuSchemas, requiredPikkuSche
 import { loadAuthOptions, getAuthMigrations } from './better-auth-schema.js';
 import { generateSchemaTypes } from './db-codegen.js';
 import { generateZodTypes } from './zod-codegen.js';
-import { tableCreationSql } from '@pikku/migrator-sql';
+import { tableCreationSql, tablesInSourceOrder } from '@pikku/migrator-sql';
 import { SqliteMigrationExecutor } from '@pikku/migrator-sql/sqlite';
 import { SqliteIntrospector } from './sqlite/sqlite-introspector.js';
 import { createSqliteKysely } from './sqlite/sqlite-kysely.js';
@@ -114,13 +114,6 @@ export function resolveDb(userConfig, rootDir, outDir, runtimeDir, dbConfig) {
     }
     return null;
 }
-/** @deprecated Use resolveDb(userConfig, ...) instead. */
-export function resolveLocalDb(sqliteDb, rootDir, outDir, runtimeDir) {
-    if (!sqliteDb)
-        return null;
-    const result = resolveDb({ sqliteDb }, rootDir, outDir, runtimeDir);
-    return result;
-}
 function resolveAgainst(root, p) {
     return isAbsolute(p) ? p : resolve(root, p);
 }
@@ -1066,6 +1059,59 @@ export async function exportSchema(rootDir, pgliteExtensions = []) {
     }
     return artifact;
 }
+/**
+ * Write the artifact a consumer reads, whether or not this package has tables.
+ *
+ * An addon with no tables still publishes, because the consumer's only other
+ * reading of an absent file is "this package cannot say", which it must treat
+ * as a broken publish. The empty artifact is the addon stating, in a file that
+ * ships, that it needs nothing.
+ */
+export async function writeSchemaArtifact(rootDir, outDir, pgliteExtensions) {
+    const artifact = await exportSchema(rootDir, pgliteExtensions);
+    const file = join(outDir, 'db', 'pikku-db-meta.gen.json');
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, `${JSON.stringify(artifact, null, 2)}\n`, 'utf8');
+    return { file, dialects: Object.keys(artifact) };
+}
+/**
+ * Read and check one addon's published artifact.
+ *
+ * The file is generated, so a malformed one is not an authoring mistake to be
+ * explained away — it is a broken publish, and every branch here says which
+ * package to go and rebuild. Answering with half an artifact would be worse
+ * than refusing: a dialect carrying tables but no SQL generates a migration
+ * that creates nothing, and the schema silently drifts from what the addon's
+ * own functions expect.
+ */
+function readSchemaArtifact(artifactPath, pkg) {
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(artifactPath, 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`The '${pkg}' addon publishes an unreadable ${ADDON_DB_ARTIFACT} ` +
+            `(${artifactPath}): ${error.message}. Rebuild the addon.`);
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`The '${pkg}' addon publishes a ${ADDON_DB_ARTIFACT} that is not an ` +
+            'object of dialects. Rebuild the addon.');
+    }
+    for (const [dialect, exported] of Object.entries(parsed)) {
+        const entry = exported;
+        const hasSql = typeof entry?.sql === 'string' && entry.sql.trim().length > 0;
+        const hasTables = typeof entry?.tables === 'object' &&
+            entry.tables !== null &&
+            !Array.isArray(entry.tables);
+        if (!hasSql || !hasTables) {
+            throw new Error(`The '${pkg}' addon publishes a ${dialect} schema that is incomplete — ` +
+                `it needs both the SQL to run and the tables that SQL creates, and it ` +
+                `has ${!hasSql ? 'no sql' : 'sql'} and ${!hasTables ? 'no tables' : 'tables'}. ` +
+                'Rebuild the addon.');
+        }
+    }
+    return parsed;
+}
 /**
  * The schema every wired addon publishes, as sources.
  *
@@ -1089,11 +1135,23 @@ export async function addonSchemaSources(rootDir, dialect, addons, logger) {
             artifactPath = require.resolve(`${addon.package}/${ADDON_DB_ARTIFACT}`);
         }
         catch {
-            // Most addons have no schema at all, so an unresolvable artifact is the
-            // ordinary case and says nothing is contributed — not that anything failed.
-            continue;
+            // Every addon publishes this file, and one with no tables publishes an
+            // empty one. Absence is therefore never "contributes nothing" — it is a
+            // package that cannot say, and the two used to be indistinguishable:
+            // the addon was skipped in silence and the mistake surfaced much later,
+            // as a function querying a table nobody created.
+            throw new Error(`The '${addon.package}' addon does not publish ${ADDON_DB_ARTIFACT}, so ` +
+                'there is no way to tell whether it ships tables. Build it with a ' +
+                "current CLI (`pikku all` writes the file, empty when there are no " +
+                'tables), and make sure the package exports and packs it:\n' +
+                `  "exports": { "./${ADDON_DB_ARTIFACT}": "./dist/.pikku/addon/db/pikku-db-meta.gen.json" }\n` +
+                '  "files": ["dist"]');
         }
-        const artifact = JSON.parse(readFileSync(artifactPath, 'utf8'));
+        const artifact = readSchemaArtifact(artifactPath, addon.package);
+        // An addon with no tables says so with an empty artifact, which is the
+        // ordinary case and contributes nothing.
+        if (Object.keys(artifact).length === 0)
+            continue;
         const exported = artifact[dialect];
         if (!exported) {
             logger.error(`The '${addon.package}' addon publishes a schema, but not for ${dialect} — ` +
@@ -1232,7 +1290,7 @@ export async function generateMigrations(resolved, rootDir, srcDirectories, logg
         }
         else {
             const statements = [];
-            for (const table of missingTables) {
+            for (const table of tablesInSourceOrder(source.desired.sql, missingTables)) {
                 // A wholly new table is the first-time case in miniature: nothing to
                 // diff against, and the source's own SQL already says exactly how to
                 // build it. Rendering the column map instead would drop the primary

package/dist/src/functions/knowledge/render.d.ts

@@ -1,4 +1,4 @@
-import type { KnowledgeIndexResult, KnowledgePlanDeferResult, KnowledgePlanProgressResult, KnowledgePlanSchemaResult, KnowledgePlanSetResult, KnowledgePlanShowResult, KnowledgeValidateResult } from '@pikku/knowledge';
+import type { KnowledgeIndexResult, KnowledgePlanDeferResult, KnowledgePlanProgressResult, KnowledgePlanSchemaResult, KnowledgePlanSetResult, KnowledgePlanShowResult, KnowledgeReconcileResult, KnowledgeValidateResult } from '@pikku/knowledge';
 export declare const renderKnowledgeValidate: (_services: unknown, { ok, notes, findings }: KnowledgeValidateResult) => void;
 export declare const renderKnowledgeIndex: (_services: unknown, { ok, check, files }: KnowledgeIndexResult) => void;
 export declare const renderKnowledgePlanSchema: (_services: unknown, { schema }: KnowledgePlanSchemaResult) => void;
@@ -6,3 +6,14 @@ export declare const renderKnowledgePlanShow: (_services: unknown, { ok, path, b
 export declare const renderKnowledgePlanProgress: (_services: unknown, { ok, path, message, done, missing, deferred, problems, }: KnowledgePlanProgressResult) => void;
 export declare const renderKnowledgePlanSet: (_services: unknown, { ok, path, problems, schema }: KnowledgePlanSetResult) => void;
 export declare const renderKnowledgePlanDefer: (_services: unknown, { ok, message }: KnowledgePlanDeferResult) => void;
+/**
+ * What to do next, and — when only a person can settle it — the question to put to
+ * them.
+ *
+ * The action's `reason` is machine wording that names the note and the frontmatter
+ * key; on `ask-user` it is deliberately NOT what gets printed as the question, because
+ * the reader there has never seen a note. The options are numbered rather than
+ * rendered as a picker: this is the fallback every harness has, and one that can do
+ * better reads the same answer as JSON.
+ */
+export declare const renderKnowledgeReconcile: (_services: unknown, { kind, reason, note, hold, notes, question }: KnowledgeReconcileResult) => void;

package/dist/src/functions/knowledge/render.js

@@ -138,3 +138,51 @@ export const renderKnowledgePlanDefer = (_services, { ok, message }) => {
     if (!ok)
         process.exitCode = 1;
 };
+/**
+ * What to do next, and — when only a person can settle it — the question to put to
+ * them.
+ *
+ * The action's `reason` is machine wording that names the note and the frontmatter
+ * key; on `ask-user` it is deliberately NOT what gets printed as the question, because
+ * the reader there has never seen a note. The options are numbered rather than
+ * rendered as a picker: this is the fallback every harness has, and one that can do
+ * better reads the same answer as JSON.
+ */
+export const renderKnowledgeReconcile = (_services, { kind, reason, note, hold, notes, question }) => {
+    if (kind === 'idle') {
+        console.log(`${dim('=')}  ${dim(reason)}`);
+        return;
+    }
+    const label = {
+        'repair-note': 'REPAIR',
+        'write-plan': 'PLAN',
+        'ask-user': 'ASK',
+        dispatch: 'BUILD',
+        hold: 'HELD',
+    };
+    const paint = kind === 'dispatch' ? added : kind === 'hold' ? dim : changed;
+    console.log(`${paint(label[kind] ?? kind.toUpperCase())}  ${note ?? ''}`.trim());
+    console.log();
+    if (question) {
+        console.log(`${dim(question.header)}`);
+        console.log(question.question);
+        question.options.forEach((option, index) => {
+            const description = option.description
+                ? `  ${dim(option.description)}`
+                : '';
+            console.log(`  ${index + 1}. ${option.label}${description}`);
+        });
+        if (question.options.length === 0)
+            console.log(dim('  (free text)'));
+        console.log();
+        console.log(`${dim('why:')}  ${dim(reason)}`);
+        return;
+    }
+    console.log(reason);
+    if (hold) {
+        console.log();
+        console.log(`${dim('held on:')}  ${hold}`);
+        for (const path of notes ?? [])
+            console.log(`  ${dim(path)}`);
+    }
+};

package/dist/src/functions/knowledge/schemas.d.ts

@@ -94,3 +94,26 @@ 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 KnowledgeReconcileOutputSchema: import("zod").ZodObject<{
+    kind: import("zod").ZodEnum<{
+        idle: "idle";
+        "repair-note": "repair-note";
+        "write-plan": "write-plan";
+        "ask-user": "ask-user";
+        dispatch: "dispatch";
+        hold: "hold";
+    }>;
+    reason: import("zod").ZodString;
+    note: import("zod").ZodOptional<import("zod").ZodString>;
+    hold: import("zod").ZodOptional<import("zod").ZodString>;
+    notes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    question: import("zod").ZodOptional<import("zod").ZodObject<{
+        header: import("zod").ZodString;
+        question: import("zod").ZodString;
+        options: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+            label: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>;

package/dist/src/functions/knowledge/schemas.js

@@ -1,4 +1,4 @@
-import { KnowledgeIndexInput, KnowledgeIndexOutput, KnowledgePlanDeferInput, KnowledgePlanDeferOutput, KnowledgePlanProgressInput, KnowledgePlanProgressOutput, KnowledgePlanSchemaInput, KnowledgePlanSchemaOutput, KnowledgePlanSetInput, KnowledgePlanSetOutput, KnowledgePlanShowInput, KnowledgePlanShowOutput, KnowledgeValidateInput, KnowledgeValidateOutput, } from '@pikku/knowledge';
+import { KnowledgeIndexInput, KnowledgeIndexOutput, KnowledgePlanDeferInput, KnowledgePlanDeferOutput, KnowledgePlanProgressInput, KnowledgePlanProgressOutput, KnowledgePlanSchemaInput, KnowledgePlanSchemaOutput, KnowledgePlanSetInput, KnowledgePlanSetOutput, KnowledgePlanShowInput, KnowledgePlanShowOutput, KnowledgeReconcileInput, KnowledgeReconcileOutput, KnowledgeValidateInput, KnowledgeValidateOutput, } from '@pikku/knowledge';
 /**
  * The knowledge command schemas, re-bound to variables declared HERE rather than
  * imported straight into the command files.
@@ -33,3 +33,5 @@ export const KnowledgePlanSetInputSchema = KnowledgePlanSetInput;
 export const KnowledgePlanSetOutputSchema = KnowledgePlanSetOutput;
 export const KnowledgePlanDeferInputSchema = KnowledgePlanDeferInput;
 export const KnowledgePlanDeferOutputSchema = KnowledgePlanDeferOutput;
+export const KnowledgeReconcileInputSchema = KnowledgeReconcileInput;
+export const KnowledgeReconcileOutputSchema = KnowledgeReconcileOutput;

package/dist/src/functions/wirings/agent/pikku-command-agent.js

@@ -2,7 +2,7 @@ import { pikkuSessionlessFunc } from '#pikku/function';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
+import { writeWiringMeta } from '../../../utils/write-wiring-meta.js';
 import { serializeAgentMap } from './serialize-agent-map.js';
 import { serializeModelAliases } from './serialize-model-aliases.js';
 export const pikkuAgent = pikkuSessionlessFunc({
@@ -38,21 +38,18 @@ export const pikkuAgent = pikkuSessionlessFunc({
         const metaData = {
             agentsMeta: agents.agentsMeta,
         };
-        const minimalMeta = stripVerboseFields(metaData);
-        await writeFileInDir(logger, agentWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
-        if (hasVerboseFields(metaData)) {
-            const verbosePath = agentWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
-            await writeFileInDir(logger, verbosePath, JSON.stringify(metaData, null, 2));
-        }
-        const jsonImportPath = getFileImportRelativePath(agentWiringMetaFile, agentWiringMetaJsonFile, packageMappings);
-        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
-        const importStatement = supportsImportAttributes
-            ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-            : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, agentWiringMetaFile, `import { pikkuState } from '@pikku/core/state'
+        await writeWiringMeta({
+            logger,
+            meta: metaData,
+            metaJsonFile: agentWiringMetaJsonFile,
+            metaFile: agentWiringMetaFile,
+            packageMappings,
+            supportsImportAttributes: schema?.supportsImportAttributes ?? false,
+            serializeMetaTS: ({ importStatement }) => `import { pikkuState } from '@pikku/core/state'
 import type { AgentsMeta } from '@pikku/core/agent'
 ${importStatement}
-pikkuState(${addonName ? `'${addonName}'` : 'null'}, 'agent', 'agentsMeta', metaData.agentsMeta as AgentsMeta)`);
+pikkuState(${addonName ? `'${addonName}'` : 'null'}, 'agent', 'agentsMeta', metaData.agentsMeta as AgentsMeta)`,
+        });
         await writeFileInDir(logger, agentMapDeclarationFile, serializeAgentMap(logger, agentMapDeclarationFile, packageMappings, functions.typesMap, agents.agentsMeta));
         return true;
     },

package/dist/src/functions/wirings/channels/pikku-command-channels.js

@@ -3,7 +3,7 @@ import { serializeFileImports } from '../../../utils/file-imports-serializer.js'
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
+import { writeWiringMeta } from '../../../utils/write-wiring-meta.js';
 export const pikkuCommandChannels = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
@@ -21,12 +21,6 @@ export const pikkuCommandChannels = pikkuSessionlessFunc({
         // (channels.files is empty). Skipping either leaves the bootstrap importing
         // a file that was never generated and the per-unit deploy bundle fails.
         await writeFileInDir(logger, channelsWiringFile, serializeFileImports('addChannel', channelsWiringFile, channels.files, packageMappings));
-        const minimalMeta = stripVerboseFields(channels.meta);
-        await writeFileInDir(logger, channelsWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
-        if (hasVerboseFields(channels.meta)) {
-            const verbosePath = channelsWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
-            await writeFileInDir(logger, verbosePath, JSON.stringify(channels.meta, null, 2));
-        }
         await writeFileInDir(logger, channelContractsMetaJsonFile, JSON.stringify(exportedContracts.channel, null, 2));
         if (hasChannelContracts) {
             const contractsJsonImportPath = getFileImportRelativePath(channelContractsMetaFile, channelContractsMetaJsonFile, packageMappings);
@@ -36,12 +30,15 @@ export const pikkuCommandChannels = pikkuSessionlessFunc({
                 : `import contractsMeta from '${contractsJsonImportPath}'`;
             await writeFileInDir(logger, channelContractsMetaFile, `${contractsImportStatement}\nexport default contractsMeta`);
         }
-        const jsonImportPath = getFileImportRelativePath(channelsWiringMetaFile, channelsWiringMetaJsonFile, packageMappings);
-        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
-        const importStatement = supportsImportAttributes
-            ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-            : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, channelsWiringMetaFile, `import { pikkuState } from '@pikku/core/state'\nimport type { ChannelsMeta } from '@pikku/core/channel'\n${importStatement}\npikkuState(null, 'channel', 'meta', metaData as ChannelsMeta)`);
+        await writeWiringMeta({
+            logger,
+            meta: channels.meta,
+            metaJsonFile: channelsWiringMetaJsonFile,
+            metaFile: channelsWiringMetaFile,
+            packageMappings,
+            supportsImportAttributes: schema?.supportsImportAttributes ?? false,
+            serializeMetaTS: ({ importStatement }) => `import { pikkuState } from '@pikku/core/state'\nimport type { ChannelsMeta } from '@pikku/core/channel'\n${importStatement}\npikkuState(null, 'channel', 'meta', metaData as ChannelsMeta)`,
+        });
         return true;
     },
     middleware: [

package/dist/src/functions/wirings/cli/pikku-command-cli.js

@@ -3,7 +3,7 @@ import { serializeFileImports } from '../../../utils/file-imports-serializer.js'
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
+import { writeWiringMeta } from '../../../utils/write-wiring-meta.js';
 export const pikkuCLI = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
@@ -21,12 +21,6 @@ export const pikkuCLI = pikkuSessionlessFunc({
         // Skipping either leaves the bootstrap importing a file that was never
         // generated and the per-unit deploy bundle fails.
         await writeFileInDir(logger, cliWiringsFile, serializeFileImports('wireCLI', cliWiringsFile, cli.files, packageMappings));
-        const minimalMeta = stripVerboseFields(cli.meta);
-        await writeFileInDir(logger, cliWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
-        if (hasVerboseFields(cli.meta)) {
-            const verbosePath = cliWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
-            await writeFileInDir(logger, verbosePath, JSON.stringify(cli.meta, null, 2));
-        }
         await writeFileInDir(logger, cliContractsMetaJsonFile, JSON.stringify(exportedContracts.cli, null, 2));
         if (hasCLIContracts) {
             const contractsJsonImportPath = getFileImportRelativePath(cliContractsMetaFile, cliContractsMetaJsonFile, packageMappings);
@@ -36,12 +30,15 @@ export const pikkuCLI = pikkuSessionlessFunc({
                 : `import contractsMeta from '${contractsJsonImportPath}'`;
             await writeFileInDir(logger, cliContractsMetaFile, `${contractsImportStatement}\nexport default contractsMeta`);
         }
-        const jsonImportPath = getFileImportRelativePath(cliWiringMetaFile, cliWiringMetaJsonFile, packageMappings);
-        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
-        const importStatement = supportsImportAttributes
-            ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-            : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, cliWiringMetaFile, `import { pikkuState } from '@pikku/core/state'\nimport { CLIMeta } from '@pikku/core/cli'\n${importStatement}\npikkuState(null, 'cli', 'meta', metaData as CLIMeta)`);
+        await writeWiringMeta({
+            logger,
+            meta: cli.meta,
+            metaJsonFile: cliWiringMetaJsonFile,
+            metaFile: cliWiringMetaFile,
+            packageMappings,
+            supportsImportAttributes: schema?.supportsImportAttributes ?? false,
+            serializeMetaTS: ({ importStatement }) => `import { pikkuState } from '@pikku/core/state'\nimport { CLIMeta } from '@pikku/core/cli'\n${importStatement}\npikkuState(null, 'cli', 'meta', metaData as CLIMeta)`,
+        });
         return true;
     },
     middleware: [

package/dist/src/functions/wirings/console/pikku-command-nodes-meta.js

@@ -1,10 +1,9 @@
 import { pikkuSessionlessFunc } from '#pikku/function';
 import { ErrorCode } from '@pikku/inspector';
-import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { readFile } from 'fs/promises';
 import { join, isAbsolute } from 'path';
-import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
+import { writeMetaSidecar } from '../../../utils/write-wiring-meta.js';
 import { validateAndBuildSecretDefinitionsMeta } from '@pikku/core/secret';
 const loadIcon = async (iconPath, rootDir, logger) => {
     if (!iconPath)
@@ -73,19 +72,12 @@ export const pikkuNodesMeta = pikkuSessionlessFunc({
             metaData.requiredParentServices = state.addonRequiredParentServices;
         }
         if (addonMetaJsonFile && (config.scaffold?.console || config.addon)) {
-            const minimalMeta = stripVerboseFields(metaData);
-            await writeFileInDir(logger, addonMetaJsonFile, JSON.stringify(minimalMeta, null, 2), { ignoreModifyComment: true });
-            if (hasVerboseFields(metaData)) {
-                const verbosePath = addonMetaJsonFile.endsWith('.gen.json')
-                    ? addonMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json')
-                    : addonMetaJsonFile.replace(/(\.\w+)$/, '-verbose$1');
-                if (verbosePath === addonMetaJsonFile) {
-                    logger.warn(`Cannot derive verbose path from ${addonMetaJsonFile}, skipping verbose metadata`);
-                }
-                else {
-                    await writeFileInDir(logger, verbosePath, JSON.stringify(metaData, null, 2), { ignoreModifyComment: true });
-                }
-            }
+            await writeMetaSidecar({
+                logger,
+                meta: metaData,
+                metaJsonFile: addonMetaJsonFile,
+                ignoreModifyComment: true,
+            });
         }
         return true;
     },

package/dist/src/functions/wirings/credentials/serialize-credentials-types.js

@@ -1,12 +1,6 @@
 import { validateAndBuildCredentialDefinitionsMeta } from '@pikku/core/credential';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-/**
- * A display name is the human-facing label a developer wrote, so an apostrophe
- * in it is ordinary. `JSON.stringify` emits a valid, escaped TypeScript string
- * literal; interpolating the raw text into a quoted one terminates the string
- * and the generated file stops parsing.
- */
-const literal = (value) => JSON.stringify(value);
+import { tsLiteral } from '../../../utils/ts-literal.js';
 export const serializeCredentialsTypes = ({ definitions, schemaLookup, credentialsFile, packageMappings, }) => {
     const credentials = validateAndBuildCredentialDefinitionsMeta(definitions, schemaLookup);
     const credentialEntries = Object.entries(credentials);
@@ -29,7 +23,7 @@ export const serializeCredentialsTypes = ({ definitions, schemaLookup, credentia
         }
         const metaParts = [
             `name: '${name}'`,
-            `displayName: ${literal(meta.displayName)}`,
+            `displayName: ${tsLiteral(meta.displayName)}`,
             `type: '${meta.type}'`,
         ];
         if (meta.oauth2) {

package/dist/src/functions/wirings/functions/pikku-command-functions.js

@@ -3,31 +3,32 @@ import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeFunctionImports } from './serialize-function-imports.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-import { stripVerboseFields, hasVerboseFields, reattachFunctionServices, } from '../../../utils/strip-verbose-meta.js';
+import { stripVerboseFields, reattachFunctionServices, reattachAgentToolDescriptions, } from '../../../utils/strip-verbose-meta.js';
+import { writeMetaSidecar, writeWiringMeta, } from '../../../utils/write-wiring-meta.js';
 import { partitionScenarioFunctions, partitionScenarioFunctionsMeta, } from '../scenarios/scenario-partition.js';
 import { serializeScenarioFunctionMeta } from '../scenarios/serialize-scenario-meta.js';
 export const pikkuFunctions = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { functions, rpc } = await getInspectorState();
+        const { functions, rpc, agents } = await getInspectorState();
         const { functionsMetaFile, functionsMetaJsonFile, functionsFile, scenarioStepsFile, scenarioStepsMetaFile, scenarioStepsMetaJsonFile, packageMappings, schema, } = config;
         const { app: appFunctionsMeta, scenario: scenarioFunctionsMeta } = partitionScenarioFunctionsMeta(functions.meta);
         let minimalMeta = stripVerboseFields(appFunctionsMeta);
         if (config.addonName) {
             minimalMeta = reattachFunctionServices(minimalMeta, appFunctionsMeta);
         }
-        await writeFileInDir(logger, functionsMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
-        // Write verbose JSON only if it has additional fields
-        if (hasVerboseFields(appFunctionsMeta)) {
-            const verbosePath = functionsMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
-            await writeFileInDir(logger, verbosePath, JSON.stringify(appFunctionsMeta, null, 2));
-        }
-        const jsonImportPath = getFileImportRelativePath(functionsMetaFile, functionsMetaJsonFile, packageMappings);
-        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
-        const importStatement = supportsImportAttributes
-            ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-            : `import metaData from '${jsonImportPath}'`;
+        minimalMeta = reattachAgentToolDescriptions(minimalMeta, appFunctionsMeta, new Set(Object.values(agents.agentsMeta).flatMap((agent) => agent.tools ?? [])));
         const packageName = config.addonName ? `'${config.addonName}'` : 'null';
-        await writeFileInDir(logger, functionsMetaFile, `import { pikkuState } from '@pikku/core/state'\nimport type { FunctionsMeta } from '@pikku/core/services'\n${importStatement}\npikkuState(${packageName}, 'function', 'meta', metaData as FunctionsMeta)`);
+        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+        await writeWiringMeta({
+            logger,
+            meta: appFunctionsMeta,
+            minimalMeta,
+            metaJsonFile: functionsMetaJsonFile,
+            metaFile: functionsMetaFile,
+            packageMappings,
+            supportsImportAttributes,
+            serializeMetaTS: ({ importStatement }) => `import { pikkuState } from '@pikku/core/state'\nimport type { FunctionsMeta } from '@pikku/core/services'\n${importStatement}\npikkuState(${packageName}, 'function', 'meta', metaData as FunctionsMeta)`,
+        });
         // For addon packages, register ALL functions (they'll be invoked by consumers)
         // For main packages, only register functions that are invoked via internal RPCs
         const isAddon = !!config.addonName;
@@ -43,13 +44,15 @@ export const pikkuFunctions = pikkuSessionlessFunc({
         // Always written, even when empty: a project that deletes its last scenario
         // must stop registering the one it had, and the scenario bootstrap imports
         // these unconditionally.
-        await writeFileInDir(logger, scenarioStepsMetaJsonFile, JSON.stringify(stripVerboseFields(scenarioFunctionsMeta), null, 2));
+        //
         // The bootstrap imports the stripped copy; the verbose one is read off disk
         // by whatever documents a scenario — the console needs `sourceFile` and
         // `exportedName` to show the code a step runs.
-        if (hasVerboseFields(scenarioFunctionsMeta)) {
-            await writeFileInDir(logger, scenarioStepsMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json'), JSON.stringify(scenarioFunctionsMeta, null, 2));
-        }
+        await writeMetaSidecar({
+            logger,
+            meta: scenarioFunctionsMeta,
+            metaJsonFile: scenarioStepsMetaJsonFile,
+        });
         await writeFileInDir(logger, scenarioStepsMetaFile, serializeScenarioFunctionMeta(getFileImportRelativePath(scenarioStepsMetaFile, scenarioStepsMetaJsonFile, packageMappings), getFileImportRelativePath(scenarioStepsMetaFile, functionsMetaFile, packageMappings), supportsImportAttributes, config.addonName));
         await writeFileInDir(logger, scenarioStepsFile, scenarioFiles.size === 0
             ? 'export {}'

package/dist/src/functions/wirings/gateway/pikku-command-gateway.js

@@ -2,8 +2,7 @@ import { pikkuSessionlessFunc } from '#pikku/function';
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
+import { writeWiringMeta } from '../../../utils/write-wiring-meta.js';
 import { serializeGatewayMeta, serializeGatewayMetaTS, } from './serialize-gateway-meta.js';
 export const pikkuGateway = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
@@ -14,14 +13,16 @@ export const pikkuGateway = pikkuSessionlessFunc({
             return undefined;
         }
         const fullMeta = serializeGatewayMeta(gateways.meta);
-        const minimalMeta = stripVerboseFields(fullMeta);
-        await writeFileInDir(logger, gatewaysWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
-        if (hasVerboseFields(fullMeta)) {
-            const verbosePath = gatewaysWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
-            await writeFileInDir(logger, verbosePath, JSON.stringify(fullMeta, null, 2));
-        }
-        const jsonImportPath = getFileImportRelativePath(gatewaysWiringMetaFile, gatewaysWiringMetaJsonFile, packageMappings);
-        await writeFileInDir(logger, gatewaysWiringMetaFile, serializeGatewayMetaTS(jsonImportPath, schema?.supportsImportAttributes ?? false));
+        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+        await writeWiringMeta({
+            logger,
+            meta: fullMeta,
+            metaJsonFile: gatewaysWiringMetaJsonFile,
+            metaFile: gatewaysWiringMetaFile,
+            packageMappings,
+            supportsImportAttributes,
+            serializeMetaTS: ({ jsonImportPath }) => serializeGatewayMetaTS(jsonImportPath, supportsImportAttributes),
+        });
         await writeFileInDir(logger, gatewaysWiringFile, serializeFileImports('wireGateway', gatewaysWiringFile, gateways.files, packageMappings));
         return true;
     },