@pikku/cli 0.11.1 → 0.11.3

package/src/utils/strip-verbose-meta.ts

@@ -0,0 +1,254 @@
+/**
+ * Utility functions to strip verbose/visualization-only fields from meta objects
+ * for creating minimal runtime-only versions.
+ *
+ * Verbose fields are those used for UI/visualization but not needed at runtime:
+ * - tags, description, summary, errors
+ * - title, displayName
+ * - usedWires, isDirectFunction, services
+ * - stepName (in workflow nodes)
+ *
+ * Note: middleware and permissions are NOT verbose - they're needed at runtime
+ * for resolving tag middleware and permissions in function-runner.ts
+ *
+ * IMPORTANT: We only strip verbose fields at the direct meta entry level.
+ * For most meta types (HTTP, Queue, Scheduler, etc.), entries have pikkuFuncName.
+ * For workflow graphs, we strip at the root level AND from nodes.
+ * We do NOT strip from deeply nested structures like CLI options where 'description' is required.
+ */
+
+const VERBOSE_FIELDS = new Set([
+  'tags',
+  'description',
+  'summary',
+  'errors',
+  'title',
+  'displayName',
+  // Note: middleware and permissions are NOT verbose - they're needed at runtime
+  // for resolving tag middleware and permissions in function-runner.ts
+  'usedWires',
+  'isDirectFunction',
+  'services',
+])
+
+/**
+ * Fields that are verbose only at the node level (workflow nodes)
+ */
+const NODE_VERBOSE_FIELDS = new Set(['stepName'])
+
+/**
+ * Strip verbose fields from an object (shallow - only direct properties)
+ */
+function stripVerboseShallow<T>(obj: T, additionalFields?: Set<string>): T {
+  if (
+    obj === null ||
+    obj === undefined ||
+    typeof obj !== 'object' ||
+    Array.isArray(obj)
+  ) {
+    return obj
+  }
+
+  const result: Record<string, unknown> = {}
+  const fieldsToStrip = additionalFields
+    ? new Set([...VERBOSE_FIELDS, ...additionalFields])
+    : VERBOSE_FIELDS
+
+  for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+    if (fieldsToStrip.has(key)) {
+      continue
+    }
+    result[key] = value
+  }
+
+  return result as T
+}
+
+/**
+ * Check if an object has any verbose fields (shallow check)
+ */
+function hasVerboseShallow(
+  obj: unknown,
+  additionalFields?: Set<string>
+): boolean {
+  if (
+    obj === null ||
+    obj === undefined ||
+    typeof obj !== 'object' ||
+    Array.isArray(obj)
+  ) {
+    return false
+  }
+
+  const fieldsToCheck = additionalFields
+    ? new Set([...VERBOSE_FIELDS, ...additionalFields])
+    : VERBOSE_FIELDS
+
+  for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+    if (fieldsToCheck.has(key) && value !== undefined) {
+      return true
+    }
+  }
+
+  return false
+}
+
+/**
+ * Strip verbose fields from a meta object.
+ *
+ * Handles different meta structure patterns:
+ * 1. Single workflow graph: { name, pikkuFuncName, nodes: {...}, description, tags }
+ *    -> Strips description, tags at root; strips stepName from each node
+ * 2. Record of meta entries: { "entryName": { pikkuFuncName, description, tags, ... } }
+ *    -> Strips description, tags from each entry (one level deep only)
+ * 3. CLI meta and others with complex nesting: preserved as-is except for pikkuFuncName entries
+ */
+export function stripVerboseFields<T>(obj: T): T {
+  if (obj === null || obj === undefined || typeof obj !== 'object') {
+    return obj
+  }
+
+  if (Array.isArray(obj)) {
+    // Array of entries - strip from each
+    return obj.map((item) => {
+      if (
+        typeof item === 'object' &&
+        item !== null &&
+        'pikkuFuncName' in (item as Record<string, unknown>)
+      ) {
+        return stripVerboseShallow(item)
+      }
+      return item
+    }) as T
+  }
+
+  const objRecord = obj as Record<string, unknown>
+
+  // Case 1: Single workflow graph (has 'nodes' and 'pikkuFuncName' at root)
+  if ('nodes' in objRecord && 'pikkuFuncName' in objRecord) {
+    const result: Record<string, unknown> = {}
+
+    for (const [key, value] of Object.entries(objRecord)) {
+      if (VERBOSE_FIELDS.has(key)) {
+        continue
+      }
+
+      if (key === 'nodes' && typeof value === 'object' && value !== null) {
+        // Strip stepName from each node
+        const nodes: Record<string, unknown> = {}
+        for (const [nodeId, node] of Object.entries(
+          value as Record<string, unknown>
+        )) {
+          nodes[nodeId] = stripVerboseShallow(node, NODE_VERBOSE_FIELDS)
+        }
+        result[key] = nodes
+      } else {
+        result[key] = value
+      }
+    }
+
+    return result as T
+  }
+
+  // Case 2: Record of meta entries (each entry has pikkuFuncName)
+  // Only strip at exactly one level deep - the immediate children
+  const result: Record<string, unknown> = {}
+
+  for (const [key, value] of Object.entries(objRecord)) {
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      const valueObj = value as Record<string, unknown>
+      // Only strip from entries that look like meta entries (have pikkuFuncName)
+      if ('pikkuFuncName' in valueObj) {
+        result[key] = stripVerboseShallow(value)
+      } else {
+        // Keep nested structures as-is (e.g., CLI programs, options)
+        result[key] = value
+      }
+    } else {
+      result[key] = value
+    }
+  }
+
+  return result as T
+}
+
+/**
+ * Check if an object has any verbose fields that would be stripped
+ */
+export function hasVerboseFields(obj: unknown): boolean {
+  if (obj === null || obj === undefined || typeof obj !== 'object') {
+    return false
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.some((item) => {
+      if (
+        typeof item === 'object' &&
+        item !== null &&
+        'pikkuFuncName' in (item as Record<string, unknown>)
+      ) {
+        return hasVerboseShallow(item)
+      }
+      return false
+    })
+  }
+
+  const objRecord = obj as Record<string, unknown>
+
+  // Case 1: Single workflow graph
+  if ('nodes' in objRecord && 'pikkuFuncName' in objRecord) {
+    // Check root level
+    if (hasVerboseShallow(objRecord)) {
+      return true
+    }
+    // Check nodes for stepName
+    const nodes = objRecord.nodes
+    if (typeof nodes === 'object' && nodes !== null) {
+      for (const node of Object.values(nodes as Record<string, unknown>)) {
+        if (hasVerboseShallow(node, NODE_VERBOSE_FIELDS)) {
+          return true
+        }
+      }
+    }
+    return false
+  }
+
+  // Case 2: Record of meta entries
+  for (const value of Object.values(objRecord)) {
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      const valueObj = value as Record<string, unknown>
+      if ('pikkuFuncName' in valueObj && hasVerboseShallow(value)) {
+        return true
+      }
+    }
+  }
+
+  return false
+}
+
+/**
+ * Write both minimal and verbose meta files
+ * Only writes verbose file if it differs from minimal
+ *
+ * @returns Object with paths that were written
+ */
+export async function writeMetaFiles(
+  writeFile: (path: string, content: string) => Promise<void>,
+  basePath: string,
+  meta: unknown
+): Promise<{ minimal: string; verbose?: string }> {
+  const minimalMeta = stripVerboseFields(meta)
+  const minimalPath = basePath.replace(/\.gen\.json$/, '.gen.json')
+  const verbosePath = basePath.replace(/\.gen\.json$/, '-verbose.gen.json')
+
+  // Always write minimal
+  await writeFile(minimalPath, JSON.stringify(minimalMeta, null, 2))
+
+  // Only write verbose if it has additional fields
+  if (hasVerboseFields(meta)) {
+    await writeFile(verbosePath, JSON.stringify(meta, null, 2))
+    return { minimal: minimalPath, verbose: verbosePath }
+  }
+
+  return { minimal: minimalPath }
+}

package/types/application-types.d.ts

@@ -22,6 +22,6 @@ export interface SingletonServices extends CoreSingletonServices<Config> {
   ) => Promise<InspectorState>
 }
 
-export interface Services extends CoreServices<SingletonServices, {}> {}
+export interface Services extends CoreServices<SingletonServices> {}
 
 export interface UserSession extends CoreUserSession {}

package/types/config.d.ts

@@ -13,23 +13,26 @@ export interface PikkuCLICoreOutputFiles {
   // Function definitions
   functionsFile: string
   functionsMetaFile: string
-  functionsMetaMinFile: string
+  functionsMetaJsonFile: string
   functionTypesFile: string
 
   // HTTP
   httpWiringsFile: string
   httpWiringMetaFile: string
+  httpWiringMetaJsonFile: string
   httpMapDeclarationFile: string
   httpTypesFile: string
 
   // Channels
   channelsWiringFile: string
   channelsWiringMetaFile: string
+  channelsWiringMetaJsonFile: string
   channelsMapDeclarationFile: string
   channelsTypesFile: string
 
   // RPC Internal
   rpcInternalWiringMetaFile: string
+  rpcInternalWiringMetaJsonFile: string
   rpcInternalMapDeclarationFile: string
 
   // RPC Exposed
@@ -38,11 +41,13 @@ export interface PikkuCLICoreOutputFiles {
   // Schedulers
   schedulersWiringFile: string
   schedulersWiringMetaFile: string
+  schedulersWiringMetaJsonFile: string
   schedulersTypesFile: string
 
   // Queue processors
   queueWorkersWiringFile: string
   queueWorkersWiringMetaFile: string
+  queueWorkersWiringMetaJsonFile: string
   queueMapDeclarationFile: string
   queueTypesFile: string
 
@@ -52,15 +57,18 @@ export interface PikkuCLICoreOutputFiles {
   workflowsWorkersFile: string
   workflowMapDeclarationFile: string
   workflowTypesFile: string
+  workflowMetaDir: string
 
   // MCP
   mcpWiringsFile: string
   mcpWiringsMetaFile: string
+  mcpWiringsMetaJsonFile: string
   mcpTypesFile: string
 
   // CLI
   cliWiringsFile: string
   cliWiringMetaFile: string
+  cliWiringMetaJsonFile: string
   cliBootstrapFile: string
   cliTypesFile: string
 
@@ -70,12 +78,19 @@ export interface PikkuCLICoreOutputFiles {
   // Middleware
   middlewareFile: string
   middlewareGroupsMetaFile: string
+  middlewareGroupsMetaJsonFile: string
 
   // Permissions
   permissionsFile: string
 
   // Application bootstrap
   bootstrapFile: string
+
+  // Package service factories (for external packages)
+  packageFile: string
+
+  // Forge
+  forgeTypesFile: string
 }
 
 export type PikkuCLIInput = {
@@ -87,6 +102,9 @@ export type PikkuCLIInput = {
   srcDirectories: string[]
   ignoreFiles?: string[]
   packageMappings: Record<string, string>
+  externalPackages?: Record<string, string> // namespace -> package name
+  externalPackage?: boolean
+  externalPackageName?: string
 
   configDir: string
   tsconfig: string
@@ -161,6 +179,18 @@ export type PikkuCLIInput = {
   stateOutput?: string
   stateInput?: string
 
+  forge?: {
+    verboseMeta?: boolean
+    node?: {
+      categories?: string[]
+      icon?: string
+      displayName?: string
+      description?: string
+    }
+  }
+
+  forgeNodesMetaJsonFile?: string
+
   filters: InspectorFilters
 } & PikkuCLICoreOutputFiles
 
@@ -173,6 +203,9 @@ export type PikkuCLIConfig = {
   srcDirectories: string[]
   ignoreFiles?: string[]
   packageMappings: Record<string, string>
+  externalPackages?: Record<string, string> // namespace -> package name
+  externalPackage?: boolean
+  externalPackageName?: string
 
   configFile?: string
   tags?: string[]
@@ -180,7 +213,7 @@ export type PikkuCLIConfig = {
 
   userSessionType?: string
   singletonServicesFactoryType?: string
-  sessionServicesFactoryType?: string
+  wireServicesFactoryType?: string
 
   configDir: string
   tsconfig: string
@@ -255,5 +288,17 @@ export type PikkuCLIConfig = {
   stateOutput?: string
   stateInput?: string
 
+  forge?: {
+    verboseMeta?: boolean
+    node?: {
+      categories?: string[]
+      icon?: string
+      displayName?: string
+      description?: string
+    }
+  }
+
+  forgeNodesMetaJsonFile?: string
+
   filters: InspectorFilters
 } & PikkuCLICoreOutputFiles

package/.pikku/function/pikku-functions-meta.min.gen.ts

@@ -1,211 +0,0 @@
-/**
- * This file was generated by @pikku/cli@0.11.1
- */
-import { pikkuState } from '@pikku/core'
-pikkuState('function', 'meta', {
-  "pikkuSchemas": {
-    "pikkuFuncName": "pikkuSchemas",
-    "inputSchemaName": null,
-    "outputSchemaName": "PikkuSchemasOutput"
-  },
-  "pikkuFetch": {
-    "pikkuFuncName": "pikkuFetch",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuWebSocketTyped": {
-    "pikkuFuncName": "pikkuWebSocketTyped",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuRPCClient": {
-    "pikkuFuncName": "pikkuRPCClient",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuQueueService": {
-    "pikkuFuncName": "pikkuQueueService",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuOpenAPI": {
-    "pikkuFuncName": "pikkuOpenAPI",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuNext": {
-    "pikkuFuncName": "pikkuNext",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "all": {
-    "pikkuFuncName": "all",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "bootstrap": {
-    "pikkuFuncName": "bootstrap",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "watch": {
-    "pikkuFuncName": "watch",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuChannels": {
-    "pikkuFuncName": "pikkuChannels",
-    "inputSchemaName": null,
-    "outputSchemaName": "PikkuChannelsOutput"
-  },
-  "pikkuChannelTypes": {
-    "pikkuFuncName": "pikkuChannelTypes",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuChannelsMap": {
-    "pikkuFuncName": "pikkuChannelsMap",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuCLIEntry": {
-    "pikkuFuncName": "pikkuCLIEntry",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuCLITypes": {
-    "pikkuFuncName": "pikkuCLITypes",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuCLI": {
-    "pikkuFuncName": "pikkuCLI",
-    "inputSchemaName": null,
-    "outputSchemaName": "PikkuCLIOutput"
-  },
-  "pikkuFunctionTypesSplit": {
-    "pikkuFuncName": "pikkuFunctionTypesSplit",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuFunctionTypes": {
-    "pikkuFuncName": "pikkuFunctionTypes",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuFunctions": {
-    "pikkuFuncName": "pikkuFunctions",
-    "inputSchemaName": null,
-    "outputSchemaName": "PikkuFunctionsOutput"
-  },
-  "pikkuServices": {
-    "pikkuFuncName": "pikkuServices",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuHTTPMap": {
-    "pikkuFuncName": "pikkuHTTPMap",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuHTTP": {
-    "pikkuFuncName": "pikkuHTTP",
-    "inputSchemaName": null,
-    "outputSchemaName": "PikkuHTTPOutput"
-  },
-  "pikkuHTTPTypes": {
-    "pikkuFuncName": "pikkuHTTPTypes",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuMCPJSON": {
-    "pikkuFuncName": "pikkuMCPJSON",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuMCPTypes": {
-    "pikkuFuncName": "pikkuMCPTypes",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuMCP": {
-    "pikkuFuncName": "pikkuMCP",
-    "inputSchemaName": null,
-    "outputSchemaName": "PikkuMCPOutput"
-  },
-  "pikkuMiddleware": {
-    "pikkuFuncName": "pikkuMiddleware",
-    "inputSchemaName": null,
-    "outputSchemaName": "PikkuMiddlewareOutput"
-  },
-  "pikkuPermissions": {
-    "pikkuFuncName": "pikkuPermissions",
-    "inputSchemaName": null,
-    "outputSchemaName": "PikkuPermissionsOutput"
-  },
-  "pikkuQueueMap": {
-    "pikkuFuncName": "pikkuQueueMap",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuQueueTypes": {
-    "pikkuFuncName": "pikkuQueueTypes",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuQueue": {
-    "pikkuFuncName": "pikkuQueue",
-    "inputSchemaName": null,
-    "outputSchemaName": "PikkuQueueOutput"
-  },
-  "pikkuPublicRPC": {
-    "pikkuFuncName": "pikkuPublicRPC",
-    "inputSchemaName": null,
-    "outputSchemaName": "PikkuPublicRPCOutput"
-  },
-  "pikkuRemoteRPC": {
-    "pikkuFuncName": "pikkuRemoteRPC",
-    "inputSchemaName": null,
-    "outputSchemaName": "PikkuRemoteRPCOutput"
-  },
-  "pikkuRPCInternalMap": {
-    "pikkuFuncName": "pikkuRPCInternalMap",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuRPCExposedMap": {
-    "pikkuFuncName": "pikkuRPCExposedMap",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuRPC": {
-    "pikkuFuncName": "pikkuRPC",
-    "inputSchemaName": null,
-    "outputSchemaName": "PikkuRPCOutput"
-  },
-  "pikkuSchedulerTypes": {
-    "pikkuFuncName": "pikkuSchedulerTypes",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuScheduler": {
-    "pikkuFuncName": "pikkuScheduler",
-    "inputSchemaName": null,
-    "outputSchemaName": "PikkuSchedulerOutput"
-  },
-  "pikkuWorkflowMap": {
-    "pikkuFuncName": "pikkuWorkflowMap",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuWorkflowTypes": {
-    "pikkuFuncName": "pikkuWorkflowTypes",
-    "inputSchemaName": null,
-    "outputSchemaName": null
-  },
-  "pikkuWorkflow": {
-    "pikkuFuncName": "pikkuWorkflow",
-    "inputSchemaName": null,
-    "outputSchemaName": "PikkuWorkflowOutput"
-  }
-})