{
    "programs": {
        "pikku": {
            "program": "pikku",
            "commands": {
                "all": {
                    "pikkuFuncId": "all",
                    "positionals": [],
                    "options": {
                        "diff": {
                            "description": "On success, emit a structural diff of the generated .pikku meta (what this run added/removed/changed) as a PIKKU_DIFF <json> line on stdout. Only emitted on exit 0.",
                            "default": false
                        },
                        "filter": {
                            "description": "Named filter(s) from pikku.config.json filters map (comma-separated)"
                        },
                        "tags": {
                            "description": "Include functions by tags (comma-separated)",
                            "short": "t"
                        },
                        "wires": {
                            "description": "Filter direct wirings by category (comma-separated)"
                        },
                        "excludeWires": {
                            "description": "Exclude direct wirings by category (comma-separated)"
                        },
                        "excludeTags": {
                            "description": "Exclude functions by tags (comma-separated)"
                        },
                        "directories": {
                            "description": "Include functions by directories (comma-separated)",
                            "short": "d"
                        },
                        "excludeDirectories": {
                            "description": "Exclude functions by directories (comma-separated)"
                        },
                        "httpMethods": {
                            "description": "Include HTTP routes by methods (comma-separated)"
                        },
                        "excludeHttpMethods": {
                            "description": "Exclude HTTP routes by methods (comma-separated)"
                        },
                        "httpRoutes": {
                            "description": "Include HTTP routes by route patterns (comma-separated)"
                        },
                        "excludeHttpRoutes": {
                            "description": "Exclude HTTP routes by route patterns (comma-separated)"
                        },
                        "names": {
                            "description": "Include functions by name patterns (supports wildcards)",
                            "short": "n"
                        },
                        "excludeNames": {
                            "description": "Exclude functions by name patterns (supports wildcards)"
                        },
                        "target": {
                            "description": "Include functions by deploy target (comma-separated: serverless, server)"
                        },
                        "excludeTarget": {
                            "description": "Exclude functions by deploy target (comma-separated: serverless, server)"
                        },
                        "forceRelativeImports": {
                            "description": "Emit relative imports even when packageMappings would apply (used by per-unit deploy codegen)",
                            "default": false
                        }
                    },
                    "description": "Generate all Pikku files (types, schemas, wirings, etc.)",
                    "isDefault": true
                },
                "bootstrap": {
                    "pikkuFuncId": "bootstrap",
                    "positionals": [],
                    "options": {},
                    "description": "Generate only type files (setup phase only)"
                },
                "audit": {
                    "pikkuFuncId": "pikkuAudit",
                    "positionals": [],
                    "options": {
                        "outdated": {
                            "description": "Also report available dependency updates",
                            "default": false
                        }
                    },
                    "description": "Audit dependencies for security advisories (always) and available updates (--outdated); writes .pikku/audit.json"
                },
                "watch": {
                    "pikkuFuncId": "watch",
                    "positionals": [],
                    "options": {
                        "hmr": {
                            "description": "Enable hot module reload for registered functions",
                            "default": false
                        }
                    },
                    "description": "Watch for file changes and regenerate automatically"
                },
                "dev": {
                    "pikkuFuncId": "dev",
                    "positionals": [],
                    "options": {
                        "port": {
                            "description": "Port for the dev server",
                            "default": "3000",
                            "short": "p"
                        },
                        "watch": {
                            "description": "Watch for file changes and regenerate",
                            "default": true
                        },
                        "hmr": {
                            "description": "Enable hot module reload",
                            "default": true
                        },
                        "coverage": {
                            "description": "Collect V8 precise coverage in-process; snapshot/reset via the console coverage RPCs",
                            "default": false
                        },
                        "test": {
                            "description": "Test mode: record service calls for scenario assertions and set PIKKU_TEST_RUN for isTestRun()",
                            "default": false
                        }
                    },
                    "description": "Start a local development server with all services wired"
                },
                "serve": {
                    "pikkuFuncId": "serve",
                    "positionals": [],
                    "options": {
                        "port": {
                            "description": "Port for the server",
                            "default": "3000",
                            "short": "p"
                        },
                        "console": {
                            "description": "Also serve the Pikku Console same-origin at /console",
                            "default": false
                        }
                    },
                    "description": "Start a server using the bundled bun or node runner (no watch, no codegen)"
                },
                "login": {
                    "pikkuFuncId": "login",
                    "positionals": [],
                    "options": {
                        "url": {
                            "description": "Server base URL (default: http://localhost:3000)",
                            "short": "u"
                        },
                        "clientId": {
                            "description": "Client identifier sent to the device flow",
                            "default": "pikku-cli"
                        },
                        "scope": {
                            "description": "Optional space-separated scopes to request"
                        },
                        "authPath": {
                            "description": "better-auth base path (default: '/auth')"
                        },
                        "open": {
                            "description": "Open the verification URL in a browser",
                            "default": true
                        }
                    },
                    "description": "Authenticate the CLI against a pikku server (device-authorization flow)"
                },
                "logout": {
                    "pikkuFuncId": "logout",
                    "positionals": [],
                    "options": {
                        "url": {
                            "description": "Server base URL to log out of (default: current)",
                            "short": "u"
                        }
                    },
                    "description": "Remove a stored CLI session"
                },
                "whoami": {
                    "pikkuFuncId": "whoami",
                    "positionals": [],
                    "options": {
                        "url": {
                            "description": "Server base URL to inspect (default: current)",
                            "short": "u"
                        }
                    },
                    "description": "Show the current CLI session"
                },
                "schemas": {
                    "pikkuFuncId": "pikkuSchemas",
                    "positionals": [],
                    "options": {},
                    "description": "Generate JSON schemas for function input/output types"
                },
                "emails": {
                    "pikkuFuncId": "",
                    "positionals": [],
                    "options": {},
                    "description": "Email template generation commands",
                    "subcommands": {
                        "init": {
                            "pikkuFuncId": "pikkuEmailsInit",
                            "positionals": [],
                            "options": {
                                "force": {
                                    "description": "Overwrite an existing email scaffold"
                                }
                            },
                            "description": "Scaffold emailTemplatesDir with starter locales, theme, partials, and a hello-world email"
                        },
                        "generate": {
                            "pikkuFuncId": "pikkuEmails",
                            "positionals": [],
                            "options": {},
                            "description": "Generate typed email renderers and metadata from emailTemplatesDir in pikku.config.json"
                        }
                    }
                },
                "db": {
                    "pikkuFuncId": "",
                    "positionals": [],
                    "options": {},
                    "description": "Local development database commands",
                    "subcommands": {
                        "migrate": {
                            "pikkuFuncId": "dbMigrate",
                            "positionals": [],
                            "options": {},
                            "description": "Apply pending SQL migrations and regenerate db/schema.gen.ts"
                        },
                        "generate": {
                            "pikkuFuncId": "dbGenerate",
                            "positionals": [],
                            "options": {},
                            "description": "Generate SQL migrations from detected schema changes"
                        },
                        "seed": {
                            "pikkuFuncId": "dbSeed",
                            "positionals": [],
                            "options": {},
                            "description": "Apply db/seed.sql to the dev database"
                        },
                        "reset": {
                            "pikkuFuncId": "dbReset",
                            "positionals": [],
                            "options": {},
                            "description": "Wipe and recreate the dev database (migrate + seed)"
                        },
                        "audit": {
                            "pikkuFuncId": "dbAudit",
                            "positionals": [],
                            "options": {},
                            "description": "Report column classifications from the manifest and flag columns with no anonymize strategy"
                        }
                    }
                },
                "scopes": {
                    "pikkuFuncId": "",
                    "positionals": [],
                    "options": {},
                    "description": "Inspect and maintain declared authorization scopes",
                    "subcommands": {
                        "audit": {
                            "pikkuFuncId": "scopesAudit",
                            "positionals": [],
                            "options": {},
                            "description": "Report scopes in the database that are no longer declared in code, and the roles holding them"
                        },
                        "prune": {
                            "pikkuFuncId": "scopesPrune",
                            "positionals": [],
                            "options": {
                                "yes": {
                                    "description": "Actually delete. Without it, prune only reports the blast radius",
                                    "short": "y",
                                    "default": false
                                }
                            },
                            "description": "Remove scopes that are no longer declared in code, cascading them out of every role"
                        }
                    }
                },
                "workspace": {
                    "pikkuFuncId": "",
                    "positionals": [],
                    "options": {},
                    "description": "Workspace-level validation and maintenance commands",
                    "subcommands": {
                        "validate": {
                            "pikkuFuncId": "workspaceValidate",
                            "positionals": [],
                            "options": {},
                            "renderName": "renderWorkspaceValidate",
                            "description": "Check the project structure for Pikku workspace compatibility"
                        }
                    }
                },
                "scenario": {
                    "pikkuFuncId": "",
                    "positionals": [],
                    "options": {},
                    "description": "Run and inspect scenarios (pikkuScenario)",
                    "subcommands": {
                        "run": {
                            "pikkuFuncId": "scenarioRun",
                            "positionals": [
                                {
                                    "name": "environment",
                                    "required": true
                                }
                            ],
                            "options": {
                                "flows": {
                                    "description": "Comma-separated flow names to run (default: all)",
                                    "short": "f"
                                },
                                "tags": {
                                    "description": "Comma-separated tags — run flows matching any",
                                    "short": "t"
                                },
                                "coverage": {
                                    "description": "Reset/snapshot server coverage per scenario (target must run with --coverage); writes coverage/scenario-coverage.json",
                                    "default": false
                                }
                            },
                            "description": "Run scenarios against a configured environment (scenarios.environments in pikku.config.json). Actor secret comes from SCENARIO_ACTOR_SECRET.",
                            "parameters": "<environment>"
                        },
                        "list": {
                            "pikkuFuncId": "scenarioList",
                            "positionals": [],
                            "options": {},
                            "description": "List scenarios with names and descriptions"
                        }
                    }
                },
                "fabric": {
                    "pikkuFuncId": "",
                    "positionals": [],
                    "options": {},
                    "description": "PikkuFabric commands (login, link, deploy, domains, secrets, logs, …)",
                    "subcommands": {
                        "validate": {
                            "pikkuFuncId": "FabricValidate",
                            "positionals": [],
                            "options": {},
                            "renderName": "renderValidate",
                            "description": "Check the project structure for fabric compatibility — prints all missing or misconfigured items with fix hints"
                        },
                        "smoke": {
                            "pikkuFuncId": "FabricSmoke",
                            "positionals": [],
                            "options": {
                                "keepTemp": {
                                    "description": "Keep the temp worktree even on success",
                                    "default": false
                                },
                                "timeoutSeconds": {
                                    "description": "Per-step timeout for install/build/codegen commands"
                                },
                                "startupTimeoutSeconds": {
                                    "description": "Timeout for waiting on pikku dev /health-check"
                                },
                                "port": {
                                    "description": "Port to use for the temporary pikku dev startup check"
                                }
                            },
                            "renderName": "renderSmoke",
                            "description": "Run a clean-room Fabric smoke test: temp worktree, install, codegen, migrate, and verify pikku dev startup"
                        },
                        "login": {
                            "pikkuFuncId": "FabricLogin",
                            "positionals": [],
                            "options": {
                                "apiKey": {
                                    "description": "Use a static API key instead of browser flow"
                                },
                                "token": {
                                    "description": "Use an existing fabric token instead of browser flow"
                                },
                                "apiUrl": {
                                    "description": "Override the fabric-api URL for this login"
                                },
                                "consoleUrl": {
                                    "description": "Override the console URL the browser opens"
                                },
                                "browser": {
                                    "description": "Open the sign-in link automatically (--no-browser to just print it)",
                                    "default": true
                                }
                            },
                            "description": "Authenticate against fabric-api"
                        },
                        "init": {
                            "pikkuFuncId": "FabricInit",
                            "positionals": [
                                {
                                    "name": "repo",
                                    "required": true
                                }
                            ],
                            "options": {
                                "name": {
                                    "description": "Override the project display name (defaults to repo name)"
                                },
                                "branch": {
                                    "description": "Default branch (defaults to main)"
                                },
                                "force": {
                                    "description": "Replace existing fabric.config.json",
                                    "default": false
                                },
                                "apiUrl": {
                                    "description": "Override the fabric-api URL for this call"
                                }
                            },
                            "parameters": "<repo>",
                            "description": "Adopt an existing git repo as a fabric project"
                        },
                        "link": {
                            "pikkuFuncId": "FabricLink",
                            "positionals": [],
                            "options": {
                                "apiUrl": {
                                    "description": "Override the fabric-api URL stored in fabric.config.json"
                                }
                            },
                            "description": "Register the current git repo as a fabric project and queue an initial deploy"
                        },
                        "addon": {
                            "pikkuFuncId": "",
                            "positionals": [],
                            "options": {},
                            "description": "Publish and install Fabric community-registry addons",
                            "subcommands": {
                                "verify": {
                                    "pikkuFuncId": "FabricAddonVerify",
                                    "positionals": [
                                        {
                                            "name": "dir",
                                            "required": false
                                        }
                                    ],
                                    "options": {},
                                    "parameters": "[dir]",
                                    "description": "Verify an addon directory is correctly built and ready to publish",
                                    "renderName": "renderAddonVerify"
                                },
                                "publish": {
                                    "pikkuFuncId": "FabricPublish",
                                    "positionals": [
                                        {
                                            "name": "dir",
                                            "required": false
                                        }
                                    ],
                                    "options": {
                                        "apiUrl": {
                                            "description": "Override the fabric-api URL for this call"
                                        }
                                    },
                                    "parameters": "[dir]",
                                    "renderName": "renderAddonVerify",
                                    "description": "Publish the addon in this directory to the community registry (pack + upload)"
                                },
                                "add": {
                                    "pikkuFuncId": "FabricAdd",
                                    "positionals": [
                                        {
                                            "name": "id",
                                            "required": true
                                        }
                                    ],
                                    "options": {
                                        "dir": {
                                            "description": "Addon dir (overrides pikku.config.json addons.addonDir, default addons/)"
                                        },
                                        "apiUrl": {
                                            "description": "Override the fabric-api URL for this call"
                                        }
                                    },
                                    "parameters": "<id>",
                                    "description": "Install an addon from the community registry into addons/ (shadcn-style)"
                                }
                            }
                        },
                        "deploy": {
                            "pikkuFuncId": "",
                            "positionals": [],
                            "options": {},
                            "description": "Plan and apply deploys for a named branch or production",
                            "subcommands": {
                                "plan": {
                                    "pikkuFuncId": "FabricDeployPlan",
                                    "positionals": [],
                                    "options": {
                                        "branch": {
                                            "description": "Target branch to deploy",
                                            "short": "b"
                                        },
                                        "production": {
                                            "description": "Plan production (always main)",
                                            "default": false
                                        }
                                    },
                                    "renderName": "renderDeployPlan",
                                    "description": "Resolve the target ref and report what a deploy would do"
                                },
                                "apply": {
                                    "pikkuFuncId": "FabricDeployApply",
                                    "positionals": [],
                                    "options": {
                                        "branch": {
                                            "description": "Target branch to deploy",
                                            "short": "b"
                                        },
                                        "production": {
                                            "description": "Deploy production (always main)",
                                            "default": false
                                        },
                                        "message": {
                                            "description": "Annotation stored on the deployment",
                                            "short": "m"
                                        },
                                        "autoApply": {
                                            "description": "Deploy without the confirmation prompt",
                                            "default": false
                                        }
                                    },
                                    "renderName": "renderDeployApply",
                                    "description": "Build + deploy a named branch or production (main)"
                                },
                                "list": {
                                    "pikkuFuncId": "FabricDeployList",
                                    "positionals": [],
                                    "options": {
                                        "branch": {
                                            "description": "Target branch",
                                            "short": "b"
                                        }
                                    },
                                    "renderName": "renderDeployList",
                                    "description": "List recent deployments for a branch"
                                },
                                "units": {
                                    "pikkuFuncId": "FabricDeployUnits",
                                    "positionals": [],
                                    "options": {
                                        "branch": {
                                            "description": "Target branch",
                                            "short": "b"
                                        }
                                    },
                                    "renderName": "renderDeployUnits",
                                    "description": "List the deployed worker units (topology) for a branch"
                                }
                            }
                        },
                        "rollback": {
                            "pikkuFuncId": "FabricRollback",
                            "positionals": [
                                {
                                    "name": "branch",
                                    "required": true
                                },
                                {
                                    "name": "target",
                                    "required": false
                                }
                            ],
                            "options": {
                                "list": {
                                    "description": "List rollback candidates",
                                    "default": false
                                },
                                "dryRun": {
                                    "description": "Show schema-compat result without switching",
                                    "default": false
                                },
                                "yes": {
                                    "description": "Skip confirmation prompts",
                                    "short": "y",
                                    "default": false
                                }
                            },
                            "parameters": "<branch> [target]",
                            "description": "Roll live back to a previous deployment artifact"
                        },
                        "secrets": {
                            "pikkuFuncId": "",
                            "positionals": [],
                            "options": {},
                            "description": "Manage stage-scoped secrets",
                            "subcommands": {
                                "set": {
                                    "pikkuFuncId": "FabricSecretsSet",
                                    "positionals": [
                                        {
                                            "name": "name",
                                            "required": true
                                        }
                                    ],
                                    "options": {
                                        "branch": {
                                            "description": "Target branch",
                                            "short": "b"
                                        },
                                        "value": {
                                            "description": "Secret value (prompted if omitted)"
                                        },
                                        "force": {
                                            "description": "Overwrite without confirmation",
                                            "default": false
                                        }
                                    },
                                    "parameters": "<name>",
                                    "description": "Set a stage-scoped secret"
                                },
                                "list": {
                                    "pikkuFuncId": "FabricSecretsList",
                                    "positionals": [],
                                    "options": {
                                        "branch": {
                                            "description": "Target branch",
                                            "short": "b"
                                        },
                                        "json": {
                                            "description": "Machine-readable output",
                                            "default": false
                                        }
                                    },
                                    "description": "List stage secrets"
                                }
                            }
                        },
                        "logs": {
                            "pikkuFuncId": "FabricLogs",
                            "positionals": [],
                            "options": {
                                "branch": {
                                    "description": "Target branch",
                                    "short": "b"
                                },
                                "deployment": {
                                    "description": "Specific deployment id"
                                },
                                "level": {
                                    "description": "Minimum level (debug/info/warn/error)"
                                },
                                "since": {
                                    "description": "Time window (e.g. 15m, 2h)"
                                },
                                "follow": {
                                    "description": "Stream new logs (SSE)",
                                    "short": "f",
                                    "default": false
                                },
                                "json": {
                                    "description": "Machine-readable output",
                                    "default": false
                                }
                            },
                            "description": "Stream or fetch logs"
                        },
                        "metrics": {
                            "pikkuFuncId": "FabricMetrics",
                            "positionals": [],
                            "options": {
                                "branch": {
                                    "description": "Target branch",
                                    "short": "b"
                                },
                                "hours": {
                                    "description": "Lookback window in hours (default 24)"
                                },
                                "function": {
                                    "description": "Filter by wire id (e.g. function name)"
                                },
                                "json": {
                                    "description": "Machine-readable output",
                                    "default": false
                                }
                            },
                            "description": "Show request rate / error rate / latency for a stage"
                        },
                        "trace": {
                            "pikkuFuncId": "FabricTrace",
                            "positionals": [
                                {
                                    "name": "traceId",
                                    "required": true
                                }
                            ],
                            "options": {
                                "branch": {
                                    "description": "Target branch",
                                    "short": "b"
                                },
                                "json": {
                                    "description": "Machine-readable output",
                                    "default": false
                                }
                            },
                            "parameters": "<traceId>",
                            "description": "Print every event for a single trace across the stage"
                        },
                        "status": {
                            "pikkuFuncId": "FabricStatus",
                            "positionals": [],
                            "options": {},
                            "renderName": "renderStatus",
                            "description": "Show the linked project status (active + in-flight deploy)"
                        },
                        "errors": {
                            "pikkuFuncId": "FabricErrors",
                            "positionals": [],
                            "options": {
                                "branch": {
                                    "description": "Target branch",
                                    "short": "b"
                                },
                                "function": {
                                    "description": "Filter by function name"
                                }
                            },
                            "renderName": "renderErrors",
                            "description": "Show recent error-level events for a branch (with traceIds)"
                        },
                        "db": {
                            "pikkuFuncId": "",
                            "positionals": [],
                            "options": {},
                            "description": "Inspect the stage database",
                            "subcommands": {
                                "schema": {
                                    "pikkuFuncId": "FabricDbSchema",
                                    "positionals": [],
                                    "options": {
                                        "branch": {
                                            "description": "Target branch",
                                            "short": "b"
                                        }
                                    },
                                    "renderName": "renderDbSchema",
                                    "description": "Show the live database schema (tables + columns)"
                                }
                            }
                        },
                        "domains": {
                            "pikkuFuncId": "",
                            "positionals": [],
                            "options": {},
                            "description": "Manage custom domains for the production stage",
                            "subcommands": {
                                "list": {
                                    "pikkuFuncId": "FabricDomainsList",
                                    "positionals": [],
                                    "options": {
                                        "apiUrl": {
                                            "description": "Override the fabric-api URL for this call"
                                        }
                                    },
                                    "description": "List custom domains for the linked project"
                                },
                                "add": {
                                    "pikkuFuncId": "FabricDomainsAdd",
                                    "positionals": [
                                        {
                                            "name": "hostname",
                                            "required": true
                                        }
                                    ],
                                    "options": {
                                        "target": {
                                            "description": "Route target: api (Backend API) or app (Frontend App)",
                                            "default": "api"
                                        },
                                        "apiUrl": {
                                            "description": "Override the fabric-api URL for this call"
                                        }
                                    },
                                    "parameters": "<hostname>",
                                    "description": "Add a custom domain to the production stage"
                                },
                                "remove": {
                                    "pikkuFuncId": "FabricDomainsRemove",
                                    "positionals": [
                                        {
                                            "name": "hostname",
                                            "required": true
                                        }
                                    ],
                                    "options": {
                                        "apiUrl": {
                                            "description": "Override the fabric-api URL for this call"
                                        }
                                    },
                                    "parameters": "<hostname>",
                                    "description": "Remove a custom domain from the production stage"
                                }
                            }
                        },
                        "llm": {
                            "pikkuFuncId": "",
                            "positionals": [],
                            "options": {},
                            "description": "Fabric AI gateway developer key commands",
                            "subcommands": {
                                "key": {
                                    "pikkuFuncId": "FabricLLMKey",
                                    "positionals": [],
                                    "options": {
                                        "shell": {
                                            "description": "Print shell export lines",
                                            "default": false
                                        },
                                        "env": {
                                            "description": "Print .env-style key-value lines",
                                            "default": false
                                        },
                                        "json": {
                                            "description": "Print machine-readable JSON",
                                            "default": false
                                        }
                                    },
                                    "renderName": "renderLLMKey",
                                    "description": "Mint or reuse a developer-scoped Fabric AI gateway key"
                                }
                            }
                        }
                    }
                },
                "fetch": {
                    "pikkuFuncId": "pikkuFetch",
                    "positionals": [],
                    "options": {},
                    "description": "Generate type-safe HTTP fetch client"
                },
                "websocket": {
                    "pikkuFuncId": "pikkuWebSocketTyped",
                    "positionals": [],
                    "options": {},
                    "description": "Generate type-safe WebSocket client"
                },
                "rpc": {
                    "pikkuFuncId": "pikkuRPCClient",
                    "positionals": [],
                    "options": {},
                    "description": "Generate RPC client wrappers"
                },
                "react-query": {
                    "pikkuFuncId": "pikkuReactQuery",
                    "positionals": [],
                    "options": {},
                    "description": "Generate React Query hooks from RPC map"
                },
                "tanstack-start": {
                    "pikkuFuncId": "pikkuTanStackStart",
                    "positionals": [],
                    "options": {},
                    "description": "Generate the TanStack Start server-function shim (makeApi)"
                },
                "realtime": {
                    "pikkuFuncId": "pikkuRealtime",
                    "positionals": [],
                    "options": {},
                    "description": "Generate the typed realtime client (PikkuRealtime websocket + SSE helper)"
                },
                "queue-service": {
                    "pikkuFuncId": "pikkuQueueService",
                    "positionals": [],
                    "options": {},
                    "description": "Generate queue service wrapper"
                },
                "openapi": {
                    "pikkuFuncId": "pikkuOpenAPI",
                    "positionals": [],
                    "options": {},
                    "description": "Generate OpenAPI specification from HTTP routes"
                },
                "nextjs": {
                    "pikkuFuncId": "pikkuNext",
                    "positionals": [],
                    "options": {},
                    "description": "Generate Next.js backend and HTTP wrappers"
                },
                "enable": {
                    "pikkuFuncId": "",
                    "positionals": [],
                    "options": {},
                    "description": "Enable Pikku features",
                    "subcommands": {
                        "rpc": {
                            "pikkuFuncId": "enableRpc",
                            "positionals": [],
                            "options": {
                                "noAuth": {
                                    "description": "Disable auth requirement",
                                    "default": false
                                }
                            },
                            "description": "Enable public RPC endpoint"
                        },
                        "console": {
                            "pikkuFuncId": "enableConsole",
                            "positionals": [],
                            "options": {
                                "noAuth": {
                                    "description": "Disable auth requirement",
                                    "default": false
                                }
                            },
                            "description": "Enable console functions"
                        },
                        "scenarios": {
                            "pikkuFuncId": "enableScenarios",
                            "positionals": [],
                            "options": {
                                "noAuth": {
                                    "description": "Disable auth requirement",
                                    "default": false
                                }
                            },
                            "description": "Enable scenario instrumentation functions"
                        },
                        "agent": {
                            "pikkuFuncId": "enableAgent",
                            "positionals": [],
                            "options": {
                                "noAuth": {
                                    "description": "Disable auth requirement",
                                    "default": false
                                }
                            },
                            "description": "Enable public agent endpoints"
                        },
                        "workflow": {
                            "pikkuFuncId": "enableWorkflow",
                            "positionals": [],
                            "options": {
                                "noAuth": {
                                    "description": "Disable auth requirement",
                                    "default": false
                                }
                            },
                            "description": "Enable workflow workers"
                        },
                        "events": {
                            "pikkuFuncId": "enableEvents",
                            "positionals": [],
                            "options": {
                                "noAuth": {
                                    "description": "Disable auth requirement",
                                    "default": false
                                }
                            },
                            "description": "Enable the realtime events channel + SSE stream (scaffolds events.gen.ts)"
                        },
                        "remote-rpc": {
                            "pikkuFuncId": "enableRemoteRpc",
                            "positionals": [],
                            "options": {
                                "noAuth": {
                                    "description": "Disable auth requirement",
                                    "default": false
                                }
                            },
                            "description": "Enable the remote internal RPC queue worker + HTTP endpoint (scaffolds rpc-remote.gen.ts)"
                        },
                        "webhook": {
                            "pikkuFuncId": "enableWebhook",
                            "positionals": [],
                            "options": {},
                            "description": "Enable the outgoing webhook delivery queue worker (scaffolds webhook.gen.ts)"
                        }
                    }
                },
                "new": {
                    "pikkuFuncId": "",
                    "positionals": [],
                    "options": {},
                    "description": "Scaffold new functions and wirings",
                    "subcommands": {
                        "function": {
                            "pikkuFuncId": "pikkuNewFunction",
                            "positionals": [
                                {
                                    "name": "name",
                                    "required": true
                                }
                            ],
                            "options": {
                                "type": {
                                    "description": "Function type: func, sessionless (default), or void",
                                    "short": "t",
                                    "default": "sessionless"
                                }
                            },
                            "description": "Create a new Pikku function file",
                            "parameters": "<name>"
                        },
                        "wiring": {
                            "pikkuFuncId": "pikkuNewWiring",
                            "positionals": [
                                {
                                    "name": "name",
                                    "required": true
                                }
                            ],
                            "options": {
                                "type": {
                                    "description": "Wiring type: http (default), channel, scheduler, queue, mcp, cli, or trigger",
                                    "short": "t",
                                    "default": "http"
                                }
                            },
                            "description": "Create a new wiring file",
                            "parameters": "<name>"
                        },
                        "middleware": {
                            "pikkuFuncId": "pikkuNewMiddleware",
                            "positionals": [
                                {
                                    "name": "name",
                                    "required": true
                                }
                            ],
                            "options": {
                                "type": {
                                    "description": "Middleware type: simple (default) or factory",
                                    "short": "t",
                                    "default": "simple"
                                }
                            },
                            "description": "Create a new middleware file",
                            "parameters": "<name>"
                        },
                        "permission": {
                            "pikkuFuncId": "pikkuNewPermission",
                            "positionals": [
                                {
                                    "name": "name",
                                    "required": true
                                }
                            ],
                            "options": {
                                "type": {
                                    "description": "Permission type: simple (default) or factory",
                                    "short": "t",
                                    "default": "simple"
                                }
                            },
                            "description": "Create a new permission file",
                            "parameters": "<name>"
                        },
                        "addon": {
                            "pikkuFuncId": "pikkuNewAddon",
                            "positionals": [
                                {
                                    "name": "name",
                                    "required": true
                                }
                            ],
                            "options": {
                                "displayName": {
                                    "description": "Human-readable display name (defaults to PascalCase of name)"
                                },
                                "description": {
                                    "description": "Package description (defaults to \"{displayName} integration for Pikku\")"
                                },
                                "category": {
                                    "description": "Forge category (defaults to \"General\")",
                                    "default": "General"
                                },
                                "dir": {
                                    "description": "Override output directory (defaults to scaffold.addonDir or cwd)",
                                    "short": "d"
                                },
                                "secret": {
                                    "description": "Include secret schema file",
                                    "default": false
                                },
                                "variable": {
                                    "description": "Include variable definition file",
                                    "default": false
                                },
                                "oauth": {
                                    "description": "Include OAuth2 credential wiring; the API service reads its access token from the credential service",
                                    "default": false
                                },
                                "credential": {
                                    "description": "Include per-user credential wiring (apikey, bearer, or oauth2)"
                                },
                                "test": {
                                    "description": "Include test harness (default: true)",
                                    "default": true
                                },
                                "openapi": {
                                    "description": "Path to OpenAPI YAML/JSON spec to generate functions from"
                                },
                                "authConfig": {
                                    "description": "Path to an auth-config JSON overriding the spec (custom auth header, delegated login)"
                                },
                                "mcp": {
                                    "description": "Add mcp: true to generated functions (expose as MCP tools)",
                                    "default": false
                                },
                                "camelCase": {
                                    "description": "Convert snake_case property names to camelCase in generated Zod schemas",
                                    "default": false
                                }
                            },
                            "description": "Scaffold a new addon package",
                            "parameters": "<name>"
                        }
                    }
                },
                "import": {
                    "pikkuFuncId": "",
                    "positionals": [],
                    "options": {},
                    "description": "Import workflows from other systems",
                    "subcommands": {
                        "n8n": {
                            "pikkuFuncId": "pikkuImportN8n",
                            "positionals": [
                                {
                                    "name": "file",
                                    "required": true
                                }
                            ],
                            "options": {
                                "out": {
                                    "description": "Output directory (defaults to scaffold.functionDir or cwd)",
                                    "short": "o"
                                }
                            },
                            "description": "Import an n8n workflow JSON export (a single workflow, an export array, or a directory of exports) into Pikku workflow graphs + stub functions",
                            "parameters": "<file>"
                        }
                    }
                },
                "versions": {
                    "pikkuFuncId": "",
                    "positionals": [],
                    "options": {},
                    "description": "Manage function contract versions",
                    "subcommands": {
                        "init": {
                            "pikkuFuncId": "pikkuVersionsInit",
                            "positionals": [],
                            "options": {
                                "force": {
                                    "description": "Overwrite existing manifest"
                                }
                            },
                            "description": "Initialize the version manifest (versions.pikku.json)"
                        },
                        "check": {
                            "pikkuFuncId": "pikkuVersionsCheck",
                            "positionals": [],
                            "options": {},
                            "description": "Validate function contracts against the version manifest"
                        },
                        "update": {
                            "pikkuFuncId": "pikkuVersionsUpdate",
                            "positionals": [],
                            "options": {},
                            "description": "Update the version manifest with current contract hashes"
                        }
                    }
                },
                "binary": {
                    "pikkuFuncId": "binary",
                    "positionals": [],
                    "options": {
                        "compileTarget": {
                            "description": "Override compilation target (e.g. bun-linux-x64). Defaults to targets in pikku.config.json."
                        }
                    },
                    "description": "Compile a TypeScript entrypoint to a self-contained native binary using bun build --compile"
                },
                "deploy": {
                    "pikkuFuncId": "",
                    "positionals": [],
                    "options": {},
                    "description": "Deploy Pikku project to cloud infrastructure",
                    "subcommands": {
                        "plan": {
                            "pikkuFuncId": "deployPlan",
                            "positionals": [],
                            "options": {
                                "provider": {
                                    "description": "Deployment provider (cloudflare, aws)",
                                    "default": "cloudflare",
                                    "short": "p"
                                },
                                "runtime": {
                                    "description": "Server runtime for the standalone provider: node (bundle.js) or bun (compiled executable)",
                                    "default": "node"
                                },
                                "resultFile": {
                                    "description": "Write structured JSON plan result to this file path"
                                }
                            },
                            "description": "Show deployment plan (what will be created, updated, deleted)"
                        },
                        "apply": {
                            "pikkuFuncId": "deployApply",
                            "positionals": [],
                            "options": {
                                "provider": {
                                    "description": "Deployment provider (cloudflare, aws)",
                                    "default": "cloudflare",
                                    "short": "p"
                                },
                                "runtime": {
                                    "description": "Server runtime for the standalone provider: node (bundle.js) or bun (compiled executable)",
                                    "default": "node"
                                },
                                "fromPlan": {
                                    "description": "Skip build pipeline, deploy from existing plan output",
                                    "default": false
                                },
                                "resultFile": {
                                    "description": "Write structured JSON deploy result to this file path"
                                }
                            },
                            "description": "Execute the deployment plan"
                        },
                        "info": {
                            "pikkuFuncId": "deployInfo",
                            "positionals": [],
                            "options": {
                                "provider": {
                                    "description": "Deployment provider (cloudflare, aws)",
                                    "default": "cloudflare",
                                    "short": "p"
                                }
                            },
                            "description": "Show project deployment info (workers, queues, crons, secrets)"
                        }
                    }
                },
                "skills": {
                    "pikkuFuncId": "",
                    "positionals": [],
                    "options": {},
                    "description": "Install bundled agent skills (Claude Code, opencode, pi; Codex/Gemini coming soon)",
                    "subcommands": {
                        "list": {
                            "pikkuFuncId": "pikkuSkillsList",
                            "positionals": [],
                            "options": {},
                            "description": "List skills bundled with @pikku/cli and which are installed"
                        },
                        "install": {
                            "pikkuFuncId": "pikkuSkillsInstall",
                            "positionals": [],
                            "options": {
                                "agent": {
                                    "description": "Target agent (claude | opencode | pi). Default: claude",
                                    "default": "claude"
                                },
                                "only": {
                                    "description": "Comma-separated list of skill names to install (default: all)"
                                },
                                "core": {
                                    "description": "Install skills whose frontmatter includes installGroups: [core]",
                                    "default": false
                                },
                                "fabric": {
                                    "description": "Install skills whose frontmatter includes installGroups: [fabric]",
                                    "default": false
                                },
                                "update": {
                                    "description": "Overwrite existing skills if already installed",
                                    "default": false
                                }
                            },
                            "description": "Copy bundled skills into the current project"
                        }
                    }
                },
                "meta": {
                    "pikkuFuncId": "",
                    "positionals": [],
                    "options": {},
                    "description": "Inspect project metadata in machine-readable form",
                    "subcommands": {
                        "context": {
                            "pikkuFuncId": "pikkuMetaContext",
                            "positionals": [],
                            "options": {},
                            "description": "Bulk project context for planners (functions, wires, middleware, permissions, workflows, capabilities, layout) in one call"
                        },
                        "clients": {
                            "pikkuFuncId": "pikkuMetaClients",
                            "positionals": [],
                            "options": {},
                            "description": "Frontend-targeted metadata: exposed RPCs, workflows, channels with their input/output type names and descriptions"
                        },
                        "functions": {
                            "pikkuFuncId": "pikkuMetaFunctionsList",
                            "positionals": [],
                            "options": {},
                            "description": "Inspect function metadata",
                            "subcommands": {
                                "list": {
                                    "pikkuFuncId": "pikkuMetaFunctionsList",
                                    "positionals": [],
                                    "options": {},
                                    "description": "List available functions (lightweight index)"
                                },
                                "get": {
                                    "pikkuFuncId": "pikkuMetaFunctionsGet",
                                    "positionals": [
                                        {
                                            "name": "functionId",
                                            "required": true
                                        }
                                    ],
                                    "options": {},
                                    "description": "Get full metadata for a function id",
                                    "parameters": "<functionId>"
                                }
                            }
                        },
                        "schemas": {
                            "pikkuFuncId": "pikkuMetaSchemasList",
                            "positionals": [],
                            "options": {},
                            "description": "Inspect generated JSON schemas",
                            "subcommands": {
                                "list": {
                                    "pikkuFuncId": "pikkuMetaSchemasList",
                                    "positionals": [],
                                    "options": {},
                                    "description": "List generated JSON schema names"
                                },
                                "get": {
                                    "pikkuFuncId": "pikkuMetaSchemasGet",
                                    "positionals": [
                                        {
                                            "name": "schemaName",
                                            "required": true
                                        }
                                    ],
                                    "options": {},
                                    "description": "Get one generated JSON schema by name",
                                    "parameters": "<schemaName>"
                                }
                            }
                        },
                        "workflows": {
                            "pikkuFuncId": "pikkuMetaWorkflowsList",
                            "positionals": [],
                            "options": {},
                            "description": "Inspect workflow metadata",
                            "subcommands": {
                                "list": {
                                    "pikkuFuncId": "pikkuMetaWorkflowsList",
                                    "positionals": [],
                                    "options": {},
                                    "description": "List available workflows (lightweight index)"
                                },
                                "get": {
                                    "pikkuFuncId": "pikkuMetaWorkflowsGet",
                                    "positionals": [
                                        {
                                            "name": "workflowId",
                                            "required": true
                                        }
                                    ],
                                    "options": {},
                                    "description": "Get full metadata for a workflow id",
                                    "parameters": "<workflowId>"
                                }
                            }
                        },
                        "middleware": {
                            "pikkuFuncId": "pikkuMetaMiddlewareList",
                            "positionals": [],
                            "options": {},
                            "description": "Inspect middleware metadata",
                            "subcommands": {
                                "list": {
                                    "pikkuFuncId": "pikkuMetaMiddlewareList",
                                    "positionals": [],
                                    "options": {},
                                    "description": "List available middleware (lightweight index)"
                                },
                                "get": {
                                    "pikkuFuncId": "pikkuMetaMiddlewareGet",
                                    "positionals": [
                                        {
                                            "name": "middlewareId",
                                            "required": true
                                        }
                                    ],
                                    "options": {},
                                    "description": "Get full metadata for a middleware id",
                                    "parameters": "<middlewareId>"
                                }
                            }
                        },
                        "permissions": {
                            "pikkuFuncId": "pikkuMetaPermissionsList",
                            "positionals": [],
                            "options": {},
                            "description": "Inspect permission metadata",
                            "subcommands": {
                                "list": {
                                    "pikkuFuncId": "pikkuMetaPermissionsList",
                                    "positionals": [],
                                    "options": {},
                                    "description": "List available permissions (lightweight index)"
                                },
                                "get": {
                                    "pikkuFuncId": "pikkuMetaPermissionsGet",
                                    "positionals": [
                                        {
                                            "name": "permissionId",
                                            "required": true
                                        }
                                    ],
                                    "options": {},
                                    "description": "Get full metadata for a permission id",
                                    "parameters": "<permissionId>"
                                }
                            }
                        },
                        "wires": {
                            "pikkuFuncId": "pikkuMetaWiresList",
                            "positionals": [],
                            "options": {},
                            "description": "Inspect wire metadata",
                            "subcommands": {
                                "list": {
                                    "pikkuFuncId": "pikkuMetaWiresList",
                                    "positionals": [],
                                    "options": {},
                                    "description": "List available wire types and counts"
                                },
                                "http": {
                                    "pikkuFuncId": "pikkuMetaWiresHttp",
                                    "positionals": [],
                                    "options": {},
                                    "description": "List HTTP wire entries"
                                },
                                "scheduler": {
                                    "pikkuFuncId": "pikkuMetaWiresScheduler",
                                    "positionals": [],
                                    "options": {},
                                    "description": "List scheduler wire entries"
                                },
                                "queue": {
                                    "pikkuFuncId": "pikkuMetaWiresQueue",
                                    "positionals": [],
                                    "options": {},
                                    "description": "List queue wire entries"
                                },
                                "channel": {
                                    "pikkuFuncId": "pikkuMetaWiresChannel",
                                    "positionals": [],
                                    "options": {},
                                    "description": "List channel wire entries"
                                },
                                "trigger": {
                                    "pikkuFuncId": "pikkuMetaWiresTrigger",
                                    "positionals": [],
                                    "options": {},
                                    "description": "List trigger wire entries"
                                },
                                "get": {
                                    "pikkuFuncId": "pikkuMetaWiresType",
                                    "positionals": [
                                        {
                                            "name": "type",
                                            "required": true
                                        }
                                    ],
                                    "options": {},
                                    "description": "Get wire entries for a type",
                                    "parameters": "<type>"
                                }
                            }
                        }
                    }
                },
                "info": {
                    "pikkuFuncId": "pikkuInfoFunctions",
                    "positionals": [],
                    "options": {
                        "limit": {
                            "description": "Maximum number of rows to display",
                            "default": "50"
                        },
                        "verbose": {
                            "description": "Show additional details (file paths, services, etc.)",
                            "default": false
                        }
                    },
                    "description": "Show information about Pikku project resources",
                    "subcommands": {
                        "functions": {
                            "pikkuFuncId": "pikkuInfoFunctions",
                            "positionals": [],
                            "options": {
                                "limit": {
                                    "description": "Maximum number of rows to display",
                                    "default": "50"
                                },
                                "verbose": {
                                    "description": "Show additional details (type, middleware, file)",
                                    "default": false
                                }
                            },
                            "description": "List all registered functions"
                        },
                        "tags": {
                            "pikkuFuncId": "pikkuInfoTags",
                            "positionals": [],
                            "options": {
                                "limit": {
                                    "description": "Maximum number of rows to display",
                                    "default": "50"
                                },
                                "verbose": {
                                    "description": "Show names instead of counts",
                                    "default": false
                                }
                            },
                            "description": "List all tags with associated functions, middleware, and permissions"
                        },
                        "middleware": {
                            "pikkuFuncId": "pikkuInfoMiddleware",
                            "positionals": [],
                            "options": {
                                "limit": {
                                    "description": "Maximum number of rows to display",
                                    "default": "50"
                                },
                                "verbose": {
                                    "description": "Show additional details (sourceFile, services)",
                                    "default": false
                                }
                            },
                            "description": "List all middleware definitions"
                        },
                        "permissions": {
                            "pikkuFuncId": "pikkuInfoPermissions",
                            "positionals": [],
                            "options": {
                                "limit": {
                                    "description": "Maximum number of rows to display",
                                    "default": "50"
                                },
                                "verbose": {
                                    "description": "Show additional details (sourceFile, services)",
                                    "default": false
                                }
                            },
                            "description": "List all permission definitions"
                        }
                    }
                }
            },
            "options": {
                "config": {
                    "description": "Path to pikku.config.json file",
                    "short": "c"
                },
                "logLevel": {
                    "description": "Set log level",
                    "short": "l",
                    "choices": [
                        "trace",
                        "debug",
                        "info",
                        "warn",
                        "error",
                        "critical"
                    ]
                },
                "output": {
                    "description": "Output format (json emits NDJSON)"
                },
                "json": {
                    "description": "Alias for --output json",
                    "default": false,
                    "short": "j"
                },
                "security": {
                    "description": "Run the data-classification security lint (scans function return types for Private/Pii/Secret leaks). Off by default — it forces expensive return-type inference on every function. Combine with --fail-on-error to gate a build/CI.",
                    "default": false
                },
                "failOnError": {
                    "description": "Fail the build on error-severity diagnostics (e.g. data-classification leaks). Default: only critical diagnostics fail.",
                    "default": false
                },
                "failOnWarn": {
                    "description": "Fail the build on warn-severity diagnostics (implies --fail-on-error).",
                    "default": false
                },
                "failOnCritical": {
                    "description": "Fail the build on critical diagnostics. Always on; accepted for symmetry with --fail-on-error/--fail-on-warn.",
                    "default": true
                },
                "tsc": {
                    "description": "After codegen, run a real tsc --noEmit over the project's tsconfig and fail on type errors. Prints full diagnostics with code frames. Off by default.",
                    "default": false
                },
                "tscSummary": {
                    "description": "Like --tsc but prints a compact one-line-per-error summary (no code frames, node_modules filtered, capped) — cheap for AI agents / CI. Fails on type errors.",
                    "default": false
                },
                "userSessionType": {
                    "description": "Specify which UserSession type to use (when multiple exist)"
                },
                "singletonServicesFactoryType": {
                    "description": "Specify which singleton services factory to use"
                },
                "wireServicesFactoryType": {
                    "description": "Specify which wire services factory to use"
                },
                "stateOutput": {
                    "description": "Save inspector state to JSON file for reuse"
                },
                "stateInput": {
                    "description": "Load inspector state from JSON file (skips inspection)"
                },
                "outDir": {
                    "description": "Override output directory (default: from pikku.config.json)",
                    "short": "o"
                }
            },
            "defaultRenderName": "defaultCLIRenderer"
        }
    },
    "renderers": {
        "defaultCLIRenderer": {
            "name": "defaultCLIRenderer",
            "exportedName": "defaultCLIRenderer",
            "services": {
                "optimized": true,
                "services": []
            },
            "filePath": "/home/runner/work/pikku/pikku/packages/cli/src/services.ts"
        }
    }
}
