@pikku/cli 0.12.105 → 0.12.107

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

@@ -1,4 +1,4 @@
-import { validateAndBuildVariableDefinitionsMeta } from '@pikku/core/ecosystem/variable';
+import { validateAndBuildVariableDefinitionsMeta } from '@pikku/core/variable';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 /**
  * A display name is the human-facing label a developer wrote, so an apostrophe
@@ -29,10 +29,19 @@ export const serializeVariablesTypes = ({ definitions, schemaLookup, variablesFi
         }
     }
     const imports = [];
-    imports.push(`import { TypedVariablesService as CoreTypedVariablesService, type VariableMeta } from '@pikku/core/ecosystem/services'`);
+    imports.push(`import {
+  TypedVariablesService as CoreTypedVariablesService,
+  type VariableMeta,
+} from '@pikku/core/services'`);
     imports.push(`import type { VariablesService } from '@pikku/core/services'`);
-    imports.push(`import type { VariableDefinitionsMeta } from '@pikku/core/ecosystem/variable'`);
-    imports.push(`import variablesMeta from './pikku-variables-meta.gen.json' with { type: 'json' }`);
+    imports.push(`/**
+ * Side-effect import of the metadata sidecar, so that tsc emits the .json
+ * alongside this file. An addon publishes only its compiled output, and a host
+ * reads that .json off disk to discover the addon's declared variables — an
+ * uncopied sidecar leaves them invisible to the host. Nothing binds it: the
+ * sidecar is not part of \`#pikku/variables\`.
+ */
+import './pikku-variables-meta.gen.json' with { type: 'json' }`);
     if (needsZod) {
         imports.push(`import type { z } from 'zod'`);
     }
@@ -43,23 +52,10 @@ export const serializeVariablesTypes = ({ definitions, schemaLookup, variablesFi
     }
     return `${imports.join('\n')}
 
-/**
- * Every variable declared in this package.
- *
- * Read from the metadata sidecar rather than inlined, so that the import above
- * forces tsc to emit the .json alongside this file. An addon publishes only its
- * compiled output, and a host reads that .json to discover the addon's declared
- * variables — an uncopied sidecar leaves them invisible to the host.
- */
-export const VARIABLES_META: VariableDefinitionsMeta =
-  variablesMeta as VariableDefinitionsMeta
-
 export interface VariablesMap {
 ${mapEntries.join('\n')}
 }
 
-export type VariableId = keyof VariablesMap
-
 const TYPED_VARIABLES_META: Record<string, VariableMeta> = {
 ${metaEntries.join(',\n')}
 }

package/dist/src/functions/wirings/virtual-user/pikku-command-virtual-user-functions.d.ts

@@ -1 +1 @@
-export declare const pikkuVirtualUserFunctions: import("#pikku").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuVirtualUserFunctions: import("#pikku/function").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

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

@@ -1,5 +1,6 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { getLeafImportPath } from '../../../utils/leaf-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeVirtualUserFunctions } from './serialize-virtual-user-functions.js';
@@ -26,9 +27,9 @@ export const pikkuVirtualUserFunctions = pikkuSessionlessFunc({
                 `Fix: declare one with definePersonas({ ... }), or remove ` +
                 `"scaffold.virtualUser" from pikku.config.json.`);
         }
-        const pathToPikkuTypes = getFileImportRelativePath(config.virtualUserFunctionsFile, config.typesDeclarationFile, config.packageMappings);
+        const leaf = (name) => getLeafImportPath(config.virtualUserFunctionsFile, name, config);
         const pathToPersonas = getFileImportRelativePath(config.virtualUserFunctionsFile, config.personasWiringFile, config.packageMappings);
-        const { schemas, functions } = serializeVirtualUserFunctions(pathToPikkuTypes, pathToPersonas, resolveScaffoldFeature('virtualUser', config.scaffold.virtualUser).auth);
+        const { schemas, functions } = serializeVirtualUserFunctions(leaf, pathToPersonas, resolveScaffoldFeature('virtualUser', config.scaffold.virtualUser).auth);
         await writeFileInDir(logger, config.virtualUserSchemasFile, schemas);
         await writeFileInDir(logger, config.virtualUserFunctionsFile, functions);
         return true;

package/dist/src/functions/wirings/virtual-user/serialize-virtual-user-functions.d.ts

@@ -25,4 +25,4 @@ export interface VirtualUserGenOutput {
  * rewrites. Keeping the schemas in a sibling module that imports nothing but
  * zod sidesteps that entirely.
  */
-export declare const serializeVirtualUserFunctions: (pathToPikkuTypes: string, pathToPersonas: string, requireAuth?: boolean) => VirtualUserGenOutput;
+export declare const serializeVirtualUserFunctions: (leaf: (name: string) => string, pathToPersonas: string, requireAuth?: boolean) => VirtualUserGenOutput;

package/dist/src/functions/wirings/virtual-user/serialize-virtual-user-functions.js

@@ -21,7 +21,7 @@
  * rewrites. Keeping the schemas in a sibling module that imports nothing but
  * zod sidesteps that entirely.
  */
-export const serializeVirtualUserFunctions = (pathToPikkuTypes, pathToPersonas, requireAuth = true) => {
+export const serializeVirtualUserFunctions = (leaf, pathToPersonas, requireAuth = true) => {
     const authFlag = requireAuth ? 'true' : 'false';
     const schemas = `/**
  * Auto-generated virtual user schemas
@@ -133,9 +133,13 @@ export const ExecuteVirtualUserRunOutput = z.object({
  * Auto-generated virtual user functions
  * Do not edit manually - regenerate with 'npx pikku'
  */
-import { pikkuFunc, pikkuSessionlessFunc, defineScope } from '${pathToPikkuTypes}'
+import { pikkuFunc, pikkuSessionlessFunc } from '${leaf('function')}'
+import { defineScope } from '${leaf('scopes')}'
 import { personaVirtualUserTarget, runVirtualUser as runVirtualUserEngine, type SchemaMap, type VirtualUserDisposition } from '@pikku/core/virtual-user'
-import { prepareVirtualUserRun, PRODUCTION_DISPOSITION } from '@pikku/core/ecosystem/virtual-user'
+import {
+  prepareVirtualUserRun,
+  PRODUCTION_DISPOSITION,
+} from '@pikku/core/virtual-user'
 import { createPersonas, personaConfigs } from '${pathToPersonas}'
 import {
   ExecuteVirtualUserRunInput,

package/dist/src/functions/wirings/webhook/pikku-command-webhook.d.ts

@@ -1 +1 @@
-export declare const pikkuWebhook: import("#pikku").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuWebhook: import("#pikku/function").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

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

@@ -1,18 +1,18 @@
-import { pikkuSessionlessFunc } from '#pikku';
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { pikkuSessionlessFunc } from '#pikku/function';
+import { getLeafImportPath } from '../../../utils/leaf-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { removeLegacyScaffoldFile } from '../../../utils/remove-legacy-scaffold-file.js';
 import { serializeWebhook } from './serialize-webhook.js';
+import { isDeployCodegen } from '../../../utils/is-deploy-codegen.js';
 export const pikkuWebhook = pikkuSessionlessFunc({
     func: async ({ logger, config, variables }) => {
-        const deployCodegenFlag = await variables.get('PIKKU_DEPLOY_CODEGEN');
-        if (deployCodegenFlag === '1') {
+        if (await isDeployCodegen(variables)) {
             return false;
         }
         if (config.webhookWorkersFile && config.webhookSchemasFile) {
-            const pathToPikkuTypes = getFileImportRelativePath(config.webhookWorkersFile, config.typesDeclarationFile, config.packageMappings);
-            const { schemas, functions } = serializeWebhook(pathToPikkuTypes);
+            const leaf = (name) => getLeafImportPath(config.webhookWorkersFile, name, config);
+            const { schemas, functions } = serializeWebhook(leaf);
             await writeFileInDir(logger, config.webhookSchemasFile, schemas);
             await writeFileInDir(logger, config.webhookWorkersFile, functions);
             await removeLegacyScaffoldFile(config.webhookWorkersFile);

package/dist/src/functions/wirings/webhook/serialize-webhook.d.ts

@@ -8,4 +8,4 @@ export interface WebhookGenOutput {
  * The handler is inlined: it is wired exactly once, so a named export would
  * only be indirection.
  */
-export declare const serializeWebhook: (pathToPikkuTypes: string) => WebhookGenOutput;
+export declare const serializeWebhook: (leaf: (name: string) => string) => WebhookGenOutput;

package/dist/src/functions/wirings/webhook/serialize-webhook.js

@@ -4,7 +4,7 @@
  * The handler is inlined: it is wired exactly once, so a named export would
  * only be indirection.
  */
-export const serializeWebhook = (pathToPikkuTypes) => {
+export const serializeWebhook = (leaf) => {
     const schemas = `/**
  * Auto-generated outgoing webhook delivery schemas
  * Do not edit manually - regenerate with 'npx pikku'
@@ -23,8 +23,9 @@ export const WebhookDelivery = z.object({
  * Auto-generated outgoing webhook delivery queue worker
  * Do not edit manually - regenerate with 'npx pikku'
  */
-import { pikkuSessionlessFunc, wireQueueWorker } from '${pathToPikkuTypes}'
-import { pikkuWebhookWorkerFunc } from '@pikku/core/ecosystem/services'
+import { pikkuSessionlessFunc } from '${leaf('function')}'
+import { wireQueueWorker } from '${leaf('queue')}'
+import { pikkuWebhookWorkerFunc } from '@pikku/core/services'
 import { WebhookDelivery } from './webhook.schemas.gen.js'
 
 wireQueueWorker({

package/dist/src/functions/wirings/workflow/pikku-command-workflow-routes.d.ts

@@ -1 +1 @@
-export declare const pikkuWorkflowRoutes: import("#pikku").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuWorkflowRoutes: import("#pikku/function").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

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

@@ -1,5 +1,5 @@
-import { pikkuSessionlessFunc } from '#pikku';
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { pikkuSessionlessFunc } from '#pikku/function';
+import { getLeafImportPath } from '../../../utils/leaf-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { removeLegacyScaffoldFile } from '../../../utils/remove-legacy-scaffold-file.js';
@@ -10,8 +10,8 @@ export const pikkuWorkflowRoutes = pikkuSessionlessFunc({
         if (config.scaffold?.workflow &&
             config.workflowRoutesFile &&
             config.workflowRoutesSchemasFile) {
-            const pathToPikkuTypes = getFileImportRelativePath(config.workflowRoutesFile, config.typesDeclarationFile, config.packageMappings);
-            const { schemas, functions } = serializeWorkflowRoutes(pathToPikkuTypes, resolveScaffoldFeature('workflow', config.scaffold?.workflow).auth);
+            const leaf = (name) => getLeafImportPath(config.workflowRoutesFile, name, config);
+            const { schemas, functions } = serializeWorkflowRoutes(leaf, resolveScaffoldFeature('workflow', config.scaffold?.workflow).auth);
             await writeFileInDir(logger, config.workflowRoutesSchemasFile, schemas);
             await writeFileInDir(logger, config.workflowRoutesFile, functions);
             await removeLegacyScaffoldFile(config.workflowRoutesFile);

package/dist/src/functions/wirings/workflow/pikku-command-workflow.d.ts

@@ -1,5 +1,5 @@
 type WorkflowCommandInput = {
     bootstrap?: boolean;
 };
-export declare const pikkuWorkflow: import("#pikku").PikkuFunctionConfig<WorkflowCommandInput, boolean | undefined, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<WorkflowCommandInput, boolean | undefined, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<WorkflowCommandInput, boolean | undefined, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuWorkflow: import("#pikku/function").PikkuFunctionConfig<WorkflowCommandInput, boolean | undefined, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<WorkflowCommandInput, boolean | undefined, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<WorkflowCommandInput, boolean | undefined, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
 export {};

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

@@ -1,8 +1,9 @@
-import { pikkuSessionlessFunc } from '#pikku';
+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 { serializeWorkflowTypes } from './serialize-workflow-types.js';
+import { serializeScenarioTypes } from './serialize-scenario-types.js';
 import { serializePersonas } from './serialize-personas.js';
 import { resolvePersonas } from '../../../utils/resolve-personas.js';
 import { serializeWorkflowRegistration } from './serialize-workflow-registration.js';
@@ -16,7 +17,7 @@ import { buildFeaturesMeta } from '../scenarios/serialize-feature-meta.js';
 import { serializeScenarioWorkflowMeta } from '../scenarios/serialize-scenario-meta.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
-import { join } from 'path';
+import { join, dirname } from 'path';
 import { rm } from 'fs/promises';
 export const pikkuWorkflow = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }, input) => {
@@ -88,9 +89,11 @@ export const pikkuWorkflow = pikkuSessionlessFunc({
         const workflowMapImportPath = getFileImportRelativePath(workflowTypesFile, workflowMapDeclarationFile, packageMappings);
         const agentMapImportPath = getFileImportRelativePath(workflowTypesFile, config.agentMapDeclarationFile, packageMappings);
         const scopesImportPath = getFileImportRelativePath(workflowTypesFile, config.scopesFile, packageMappings);
-        const scenarioStepMapImportPath = getFileImportRelativePath(workflowTypesFile, config.scenarioStepMapDeclarationFile, packageMappings);
-        const personasImportPath = getFileImportRelativePath(workflowTypesFile, config.personasWiringFile, packageMappings);
-        await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath, rpcMapImportPath, workflowMapImportPath, agentMapImportPath, scopesImportPath, scenarioStepMapImportPath, personasImportPath));
+        await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath, getFileImportRelativePath(workflowTypesFile, config.middlewareTypesFile, packageMappings), getFileImportRelativePath(workflowTypesFile, config.authGuardsFile, packageMappings), rpcMapImportPath, workflowMapImportPath, agentMapImportPath, scopesImportPath));
+        // Scenarios get their own barrel: a scenario is a testing primitive, and
+        // mixing it into the workflow barrel meant every project that only ships
+        // workflows still imported the whole scenario surface.
+        await writeFileInDir(logger, config.scenarioTypesFile, serializeScenarioTypes(getFileImportRelativePath(config.scenarioTypesFile, functionTypesFile, packageMappings), getFileImportRelativePath(config.scenarioTypesFile, config.middlewareTypesFile, packageMappings), getFileImportRelativePath(config.scenarioTypesFile, workflowTypesFile, packageMappings), getFileImportRelativePath(config.scenarioTypesFile, config.scenarioStepMapDeclarationFile, packageMappings), getFileImportRelativePath(config.scenarioTypesFile, config.personasWiringFile, packageMappings)));
         // Rides the workflow command rather than getting its own codegen node, so
         // it can't drift out of the two hand-maintained ordering lists.
         await writeFileInDir(logger, config.scenarioStepMapDeclarationFile, serializeScenarioStepMap(logger, config.scenarioStepMapDeclarationFile, packageMappings, typesMap, functionState.meta));
@@ -101,6 +104,12 @@ export const pikkuWorkflow = pikkuSessionlessFunc({
             const agentMapImportPath = getFileImportRelativePath(config.personasWiringFile, config.agentMapDeclarationFile, packageMappings);
             const exposedRpcMapImportPath = getFileImportRelativePath(config.personasWiringFile, config.rpcMapDeclarationFile, packageMappings);
             await writeFileInDir(logger, config.personasWiringFile, serializePersonas(personas, agentMapImportPath, exposedRpcMapImportPath));
+            // Same reason as the scenario meta above: a project generated before this
+            // moved to `scenarios/` still has a copy under `workflow/`, and tsc
+            // compiles every file in the output tree whether anything imports it.
+            await rm(join(dirname(workflowTypesFile), 'pikku-personas.gen.ts'), {
+                force: true,
+            });
             // Fixed path getPersonasMeta() reads; kept out of workflow/meta, which
             // getWorkflowMeta() globs as workflows.
             await writeFileInDir(logger, join(config.outDir, 'workflow', 'personas.gen.json'), JSON.stringify(personas, null, 2));

package/dist/src/functions/wirings/workflow/serialize-personas.d.ts

@@ -1,4 +1,4 @@
-import type { ResolvedPersona } from '@pikku/core/ecosystem/services';
+import type { ResolvedPersona } from '@pikku/core/services';
 /**
  * The runtime half of `definePersonas()`.
  *

package/dist/src/functions/wirings/workflow/serialize-personas.js

@@ -8,10 +8,10 @@
  */
 export const serializePersonas = (personas, agentMapImportPath, rpcMapImportPath) => {
     return `/** Personas declared with definePersonas() */
-import { createHttpPersonas } from '@pikku/core/ecosystem/persona'
-import type { HttpPersonasConfig } from '@pikku/core/ecosystem/persona'
+import { createHttpPersonas } from '@pikku/core/persona'
+import type { HttpPersonasConfig } from '@pikku/core/persona'
 import type { ScenarioPersona } from '@pikku/core/services'
-import type { ResolvedPersona } from '@pikku/core/ecosystem/services'
+import type { ResolvedPersona } from '@pikku/core/services'
 import type { AgentMap } from '${agentMapImportPath}'
 import type { FlattenedRPCMap } from '${rpcMapImportPath}'
 

package/dist/src/functions/wirings/workflow/serialize-scenario-step-map.d.ts

@@ -1,4 +1,3 @@
 import { type TypesMap } from '@pikku/inspector';
-import type { FunctionsMeta } from '@pikku/core/ecosystem/services';
-import type { Logger } from '@pikku/core/services';
+import type { FunctionsMeta, Logger } from '@pikku/core/services';
 export declare const serializeScenarioStepMap: (logger: Logger, relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta) => string;

package/dist/src/functions/wirings/workflow/serialize-scenario-types.d.ts

@@ -0,0 +1,2 @@
+export declare const sharedWorkflowConfigFields = "  title?: string\n  description?: string\n  tags?: string[]\n  expose?: boolean\n  internal?: boolean\n  override?: string\n  version?: number\n  remote?: boolean\n  mcp?: boolean\n  readonly?: boolean\n  approvalRequired?: boolean\n  approvalDescription?: InputSchema extends StandardSchemaV1 ? PikkuApprovalDescription<InferSchemaOutput<InputSchema>> : never\n  middleware?: PikkuMiddleware[]\n  input?: InputSchema\n  output?: OutputSchema\n  node?: NodeConfig\n  errors?: Array<typeof PikkuError>\n  inline?: boolean";
+export declare const serializeScenarioTypes: (functionTypesImportPath: string, middlewareTypesImportPath: string, workflowTypesImportPath: string, scenarioStepMapImportPath: string, personasImportPath: string) => string;