@bpmnkit/docspack 0.0.1

package/.llms/chunks/cli.generate.md

@@ -0,0 +1,52 @@
+# casen generate
+
+`casen generate bpmn` produces BPMN 2.0 files without the interactive TUI. It has three operating
+modes: template, definition (full JSON), and modify-existing (patch). Auto-layout is applied in all modes.
+
+
+## Commands
+
+```
+casen generate
+└── bpmn    — generate or modify a BPMN file
+```
+
+
+## Template mode
+
+Pick a built-in template by name. Use `--process-id` and `--name` to customise the identifiers.
+
+```sh
+casen generate bpmn --template minimal --process-id order --name "Order Processing"
+casen generate bpmn --template approval --process-id leave-request
+casen generate bpmn --template parallel --process-id enrichment --name Enrichment
+casen generate bpmn --template timer-start --process-id nightly-sync
+```
+
+| Template | Pattern |
+|---|---|
+| `empty` | Start event only — bare skeleton |
+| `minimal` | Start → service task → end |
+| `user-task` | Start → user task → end |
+| `call-activity` | Start → call activity → end |
+| `business-rule` | Start → business rule task → end |
+| `approval` | Start → user task → XOR gateway → approve/reject paths |
+| `parallel` | Start → parallel fork → 2 service tasks → join → end |
+| `inclusive` | Start → inclusive gateway → 2 conditional tasks → merge → end |
+| `timer-start` | Timer start event → service task → end |
+| `message-start` | Message start event → service task → end |
+| `error-boundary` | Service task with error boundary → two end events |
+| `subprocess` | Start → embedded sub-process → end |
+| `event-subprocess` | Process with a non-interrupting error event sub-process |
+
+### Flags
+
+| Flag | Short | Description | Default |
+|---|---|---|---|
+| `--template` | | Template name (see table above) | `minimal` |
+| `--process-id` | `-i` | Process element ID | `process` |
+| `--name` | `-n` | Process display name | — |
+| `--output` | `-o` | Output file path (`-` for stdout) | `<process-id>.bpmn` |
+
+---
+Source: https://docs.bpmnkit.com/cli/generate/

package/.llms/chunks/cli.generate.modify-existing-mode-input.md

@@ -0,0 +1,59 @@
+# casen generate — Modify-existing mode (`--input`)
+
+Load an existing `.bpmn` file and patch it — add elements and flows, then re-apply auto-layout.
+The default output overwrites the input file.
+
+### Inspect the current state
+
+Use `--dump-compact` to print the file's CompactDiagram JSON. Use this to discover existing
+element IDs before writing a patch.
+
+```sh
+casen generate bpmn --input order.bpmn --dump-compact
+```
+
+Output is a `CompactDiagram` JSON object — the same format accepted by `--definition`.
+
+### Add elements and flows
+
+```sh
+# Add a rejection path to an existing gateway with id "gw"
+casen generate bpmn --input order.bpmn \
+  --patch '{"elements":[
+    {"id":"notify",     "type":"serviceTask","name":"Notify Customer","jobType":"notify-worker"},
+    {"id":"end-reject", "type":"endEvent",   "name":"Rejected"}
+  ],"flows":[
+    {"id":"fn1","from":"gw",     "to":"notify",     "condition":"= not approved","name":"No"},
+    {"id":"fn2","from":"notify", "to":"end-reject"}
+  ]}'
+```
+
+Patch mode appends to the **first process** in the file. Flows in the patch can reference existing
+element IDs — they are not required to be new.
+
+### Pipe a patch from AI output
+
+```sh
+# AI generates the patch JSON, pipe it in
+echo '{"elements":[...],"flows":[...]}' | casen generate bpmn --input order.bpmn
+```
+
+### Normalize layout
+
+Run `--input` without `--patch` to re-apply auto-layout without changing the process model:
+
+```sh
+casen generate bpmn --input messy.bpmn --output clean.bpmn
+```
+
+### Flags for `--input` mode
+
+| Flag | Description | Default |
+|---|---|---|
+| `--input` / `-f` | Existing `.bpmn` file to load | — |
+| `--patch` | JSON patch: `{"elements":[...],"flows":[...]}` | — |
+| `--dump-compact` | Print CompactDiagram JSON of `--input` and exit | — |
+| `--output` / `-o` | Output path (`-` for stdout) | Overwrites `--input` file |
+
+---
+Source: https://docs.bpmnkit.com/cli/generate/

package/.llms/chunks/cli.generate.typical-ai-workflow.md

@@ -0,0 +1,18 @@
+# casen generate — Typical AI workflow
+
+```sh
+# 1. Inspect the existing file — AI learns element IDs
+casen generate bpmn --input order.bpmn --dump-compact
+
+# 2. Check the schema if needed
+casen generate bpmn --help-schema
+
+# 3. AI generates patch JSON and pipes it in
+echo '{"elements":[...],"flows":[...]}' | casen generate bpmn --input order.bpmn
+
+# 4. Verify the result
+casen view bpmn order.bpmn
+```
+
+---
+Source: https://docs.bpmnkit.com/cli/generate/

package/.llms/chunks/cli.plugin-authoring.md

@@ -0,0 +1,59 @@
+# casen Plugin Authoring
+
+casen plugins are ordinary npm packages that export a `CasenPlugin` object. Once installed, their
+commands appear in the main TUI and in shell tab-completion alongside the built-in ones.
+
+
+## Scaffold a new plugin
+
+The fastest way to start is with the official scaffolding tool:
+
+```sh
+pnpm create @bpmnkit/casen-plugin
+# or: npx @bpmnkit/create-casen-plugin
+# or: bunx @bpmnkit/create-casen-plugin
+```
+
+The tool runs interactively:
+
+```
+  @bpmnkit/create-casen-plugin — casen plugin scaffolding
+
+  Plugin name (npm package name): casen-deploy
+  Display name             (Deploy):
+  Description              (): Git-tag-aware deploys for casen
+  Author                   (): acme
+
+  Initialize git repo? (Y/n): Y
+
+  ✓ package.json
+  ✓ tsconfig.json
+  ✓ src/index.ts
+  ✓ .gitignore
+  ✓ git init
+
+  Done! Created casen-deploy at ./casen-deploy
+```
+
+### Non-interactive mode
+
+Pass flags to skip all prompts — useful in CI or cookiecutter scripts:
+
+```sh
+pnpm create @bpmnkit/casen-plugin \
+  --name casen-deploy \
+  --description "Git-tag-aware deploys for casen" \
+  --author acme \
+  --no-git
+```
+
+| Flag | Description |
+|---|---|
+| `--name` / `-n` | npm package name (first positional arg also works) |
+| `--display-name` | Human-readable name shown in `casen plugin list` |
+| `--description` / `-d` | One-line description |
+| `--author` / `-a` | Author name or npm username |
+| `--no-git` | Skip `git init` |
+
+---
+Source: https://docs.bpmnkit.com/cli/plugin-authoring/

package/.llms/chunks/cli.plugin-authoring.plugin-naming-conventions.md

@@ -0,0 +1,11 @@
+# casen Plugin Authoring — Plugin naming conventions
+
+| Convention | Reason |
+|---|---|
+| Name packages `casen-<feature>` | Predictable, easy to search |
+| Set `id` to a reverse-domain string | Avoids conflicts across organisations |
+| Keep each group name unique | casen merges all groups into one flat namespace |
+| Prefix group name with your org for internal plugins | e.g. `acme-deploy` avoids clashing with a published `casen-deploy` |
+
+---
+Source: https://docs.bpmnkit.com/cli/plugin-authoring/

package/.llms/chunks/cli.plugin-authoring.test-locally.md

@@ -0,0 +1,41 @@
+# casen Plugin Authoring — Test locally
+
+Build and install your plugin from the local directory:
+
+```sh
+cd casen-deploy
+pnpm install
+pnpm build
+
+casen plugin install ./casen-deploy
+```
+
+Restart casen. Your commands appear under `casen deploy` (or whatever group name you chose).
+
+To uninstall during development:
+
+```sh
+casen plugin remove casen-deploy
+```
+
+
+## Publish to npm
+
+When you're ready to share:
+
+```sh
+cd casen-deploy
+npm publish
+```
+
+The `prepublishOnly` script in the generated `package.json` runs `tsc` automatically before
+publishing, so `dist/` is always up to date.
+
+Because `"casen-plugin"` is in `keywords`, your package is immediately discoverable via:
+
+```sh
+casen plugin search deploy
+```
+
+---
+Source: https://docs.bpmnkit.com/cli/plugin-authoring/

package/.llms/chunks/cli.plugin-authoring.the-bpmnkit-cli-sdk-sdk.md

@@ -0,0 +1,82 @@
+# casen Plugin Authoring — The `@bpmnkit/cli-sdk` SDK
+
+Install the SDK as a devDependency in your plugin:
+
+```sh
+pnpm add -D @bpmnkit/cli-sdk
+```
+
+It exports all types you need — no runtime dependency on casen internals.
+
+### `CasenPlugin`
+
+The root export. Default-export one instance of this from `dist/index.js`:
+
+```typescript
+interface CasenPlugin {
+  id: string          // reverse-domain ID, e.g. "com.acme.casen-deploy"
+  name: string        // shown in "casen plugin list"
+  version: string
+  groups: CommandGroup[]
+}
+```
+
+### `CommandGroup`
+
+Maps to one top-level token in the CLI (`casen <group>`). The name must be unique across all
+installed plugins and the casen core commands:
+
+```typescript
+interface CommandGroup {
+  name: string        // kebab-case, e.g. "deploy"
+  aliases?: string[]
+  description: string
+  commands: Command[]
+}
+```
+
+### `Command`
+
+A single executable action within a group (`casen <group> <command>`):
+
+```typescript
+interface Command {
+  name: string
+  aliases?: string[]
+  description: string
+  args?: ArgSpec[]
+  flags?: FlagSpec[]
+  examples?: Example[]
+  run(ctx: RunContext): Promise<void>
+}
+```
+
+### `RunContext`
+
+Passed to every `run()` function. Use it to read arguments, write output, and access
+authenticated Camunda clients:
+
+```typescript
+interface RunContext {
+  positional: string[]          // positional args after <group> <command>
+  flags: ParsedFlags            // { flagName: value }
+  output: OutputWriter          // table / json / yaml renderer
+  getClient(): Promise<unknown>       // Camunda C8 REST client
+  getAdminClient(): Promise<unknown>  // Camunda Admin API client
+}
+```
+
+### `OutputWriter`
+
+Use `ctx.output` for all output so the `--output` flag (table / json / yaml) is respected:
+
+```typescript
+ctx.output.ok("Done.")                          // ✓ Done.
+ctx.output.info("Deploying…")                   // → Deploying…
+ctx.output.printList({ items }, columns)        // table of rows
+ctx.output.printItem(singleObject)              // key-value pairs
+ctx.output.print(anything)                      // raw, format-aware
+```
+
+---
+Source: https://docs.bpmnkit.com/cli/plugin-authoring/

package/.llms/chunks/cli.plugin-authoring.what-gets-generated.md

@@ -0,0 +1,69 @@
+# casen Plugin Authoring — What gets generated
+
+```
+casen-deploy/
+├── package.json       # "casen-plugin" keyword pre-set; no manual step needed
+├── tsconfig.json      # standalone, no monorepo dependency
+├── .gitignore
+└── src/
+    └── index.ts       # CasenPlugin default export with an example command
+```
+
+### Generated `package.json`
+
+```json
+{
+  "name": "casen-deploy",
+  "version": "0.1.0",
+  "description": "Git-tag-aware deploys for casen",
+  "type": "module",
+  "main": "dist/index.js",
+  "keywords": ["casen-plugin"],
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "prepublishOnly": "tsc"
+  },
+  "devDependencies": {
+    "@bpmnkit/cli-sdk": "latest",
+    "typescript": "latest"
+  }
+}
+```
+
+The `"casen-plugin"` keyword is injected automatically — it is how `casen plugin search` discovers
+your package on npm once published.
+
+### Generated `src/index.ts`
+
+```typescript
+import type { CasenPlugin } from "@bpmnkit/cli-sdk"
+
+const plugin: CasenPlugin = {
+  id: "com.acme.casen-deploy",
+  name: "Deploy",
+  version: "0.1.0",
+  groups: [
+    {
+      name: "deploy",
+      description: "Deploy commands",
+      commands: [
+        {
+          name: "hello",
+          description: "Example command — replace with your own",
+          async run(ctx) {
+            ctx.output.ok("Hello from Deploy!")
+          },
+        },
+      ],
+    },
+  ],
+}
+
+export default plugin
+```
+
+Replace the example command with your own logic. Add as many command groups and commands as needed.
+
+---
+Source: https://docs.bpmnkit.com/cli/plugin-authoring/

package/.llms/chunks/cli.plugin-authoring.writing-commands.md

@@ -0,0 +1,84 @@
+# casen Plugin Authoring — Writing commands
+
+### Positional arguments
+
+```typescript
+{
+  name: "release",
+  description: "Tag and deploy the current process version",
+  args: [
+    { name: "process-id", description: "BPMN process ID", required: true },
+    { name: "tag",        description: "Release tag, e.g. v1.2.0",   required: true },
+  ],
+  async run(ctx) {
+    const processId = ctx.positional[0]
+    const tag = ctx.positional[1]
+    if (!processId || !tag) throw new Error("Missing required arguments")
+    // ...
+  },
+}
+```
+
+### Flags
+
+```typescript
+{
+  name: "release",
+  flags: [
+    {
+      name: "dry-run",
+      short: "n",
+      description: "Show what would happen without making changes",
+      type: "boolean",
+      default: false,
+    },
+    {
+      name: "env",
+      description: "Target environment",
+      type: "string",
+      default: "production",
+      enum: ["staging", "production"],
+    },
+  ],
+  async run(ctx) {
+    const dryRun = ctx.flags["dry-run"] === true
+    const env = ctx.flags.env as string
+    // ...
+  },
+}
+```
+
+### Calling the Camunda API
+
+Cast `getClient()` to `CamundaClient` from `@bpmnkit/api` if you need full type coverage,
+or access it generically via the unknown type:
+
+```typescript
+import type { CamundaClient } from "@bpmnkit/api"
+
+async run(ctx) {
+  const client = await ctx.getClient() as CamundaClient
+  const { items } = await client.processDefinition.searchProcessDefinitions({})
+  ctx.output.printList({ items }, [
+    { key: "bpmnProcessId", header: "PROCESS ID" },
+    { key: "name",          header: "NAME" },
+    { key: "version",       header: "VER" },
+  ])
+},
+```
+
+### Throwing errors
+
+Throw a plain `Error` for user-facing errors. casen catches it, prints `error: <message>` to
+stderr, and exits with code 1:
+
+```typescript
+async run(ctx) {
+  const name = ctx.positional[0]
+  if (!name) throw new Error("Missing required argument: <name>")
+  // ...
+}
+```
+
+---
+Source: https://docs.bpmnkit.com/cli/plugin-authoring/

package/.llms/chunks/cli.plugins.bpmnkit-casen-report.md

@@ -0,0 +1,39 @@
+# casen Plugins — `@bpmnkit/casen-report`
+
+Render HTML reports from Camunda 8 incident and SLA data
+
+### Installation
+
+```sh
+casen plugin install @bpmnkit/casen-report
+```
+
+| Command | Description |
+|---------|-------------|
+| `casen report incidents` | Generate an HTML report of current incidents grouped by process |
+| `casen report sla` | Generate an SLA compliance report for process instances |
+
+---
+
+
+## `@bpmnkit/casen-worker-ai`
+
+AI task worker plugin for casen — classify, summarize, extract, and decide using Claude
+
+### Installation
+
+```sh
+casen plugin install @bpmnkit/casen-worker-ai
+```
+
+| Command | Description |
+|---------|-------------|
+| `casen ai-worker classify` | Classify text into one of the given categories |
+| `casen ai-worker summarize` | Summarize text to a given length and style |
+| `casen ai-worker extract` | Extract structured fields from unstructured text |
+| `casen ai-worker decide` | Make a boolean decision based on a question, context, and optional policy |
+
+---
+
+---
+Source: https://docs.bpmnkit.com/cli/plugins/

package/.llms/chunks/cli.plugins.bpmnkit-casen-worker-http.md

@@ -0,0 +1,23 @@
+# casen Plugins — `@bpmnkit/casen-worker-http`
+
+Example casen worker plugin — processes HTTP connector jobs using the JSONPlaceholder API
+
+### Installation
+
+```sh
+casen plugin install @bpmnkit/casen-worker-http
+```
+
+| Command | Description |
+|---------|-------------|
+| `casen http-worker start` | Subscribe to HTTP connector jobs and complete them with live API data |
+
+---
+
+
+## Authoring Plugins
+
+See the [Plugin Authoring](/cli/plugin-authoring/) guide to build and publish your own `casen` plugin.
+
+---
+Source: https://docs.bpmnkit.com/cli/plugins/

package/.llms/chunks/cli.plugins.md

@@ -0,0 +1,25 @@
+# casen Plugins
+
+:::note[Auto-generated]
+This page is generated from `plugins-cli/*/package.json` during the docs build. Do not edit manually.
+:::
+
+Official plugins extend `casen` with domain-specific command groups. Install them with:
+
+```sh
+casen plugin install <name>
+```
+
+
+## Available Plugins
+
+| Plugin | Description |
+|--------|-------------|
+| [`@bpmnkit/casen-report`](#-bpmnkit-casen-report) | Render HTML reports from Camunda 8 incident and SLA data |
+| [`@bpmnkit/casen-worker-ai`](#-bpmnkit-casen-worker-ai) | AI task worker plugin for casen — classify, summarize, extract, and decide using Claude |
+| [`@bpmnkit/casen-worker-http`](#-bpmnkit-casen-worker-http) | Example casen worker plugin — processes HTTP connector jobs using the JSONPlaceholder API |
+
+---
+
+---
+Source: https://docs.bpmnkit.com/cli/plugins/

package/.llms/chunks/cli.skills.deploy.md

@@ -0,0 +1,24 @@
+# AIKit Skills — `/deploy`
+
+Gate a BPMN process on deploy-readiness, then deploy it to local Reebe or Camunda 8.
+
+```
+/deploy invoice-approval.bpmn
+```
+
+**What it does:**
+
+1. Runs `casen lint lint <file> --profile deploy` — stops if it reports any errors
+2. Deploys via `casen deploy deploy <file>` (local) or `casen deploy deploy <file> --target camunda8`
+3. Verifies with `casen process-definition list`
+4. Reminds you to start any scaffolded workers and provision any `{{secrets.NAME}}` the process references
+
+**Targets:**
+
+- **Local Reebe** — deploys via `ZEEBE_ADDRESS` (default `http://localhost:26500`). Start Reebe first: `casen reebe start --port 26500`
+- **Camunda 8** — deploys using the active `casen` profile. Set one up: `casen profile create`
+
+---
+
+---
+Source: https://docs.bpmnkit.com/cli/skills/

package/.llms/chunks/cli.skills.implement.md

@@ -0,0 +1,36 @@
+# AIKit Skills — `/implement`
+
+End-to-end process implementation from a natural language description.
+
+```
+/implement an invoice approval process for accounts payable
+/implement employee onboarding with Okta provisioning and Jira ticket creation
+/implement a supplier contract review workflow with DocuSign e-signature
+```
+
+**What it does:**
+
+1. Resolves external interactions via `casen connector search`/`show`
+2. Writes a `ProcessPlan` JSON file
+3. Compiles it with `casen synth`, fixing any reported problems in the plan and retrying
+4. Adds test scenarios and runs `casen test`
+5. Scaffolds a worker stub for every job type with no existing worker or connector
+6. Presents a summary and asks where to deploy
+
+**Output:**
+```
+BPMN file: invoice-approval.bpmn
+
+Connectors used: none
+Workers: reused none / scaffolded workers/validate-invoice/, workers/trigger-payment/
+Tests: 3/3 passed
+
+Deploy to local Reebe, deploy to Camunda 8, or skip?
+```
+
+See [Building Processes with AI](/guides/ai-implement/) for a full walkthrough.
+
+---
+
+---
+Source: https://docs.bpmnkit.com/cli/skills/

package/.llms/chunks/cli.skills.md

@@ -0,0 +1,29 @@
+# AIKit Skills
+
+`casen` ships four lightweight Claude Code slash commands that automate the process
+development lifecycle — from natural language description to deployed, running process.
+They drive `casen` directly (no MCP server, no proxy daemon).
+
+For the full skill set — `/bpmnkit:implement`, `:extend`, `:agent`, `:connect`, plus generated
+reference docs the skills read before authoring a plan — install the
+[Claude Code plugin](/guides/ai-implement/#the-claude-code-plugin) instead.
+
+
+## Installation
+
+```sh
+casen skills install
+```
+
+Copies the skill files into `.claude/commands/` in the current project directory.
+Once installed, they appear in Claude Code's slash command picker.
+
+```sh
+# Reinstall or overwrite existing skills
+casen skills install --force
+```
+
+---
+
+---
+Source: https://docs.bpmnkit.com/cli/skills/

package/.llms/chunks/cli.skills.no-mcp-server-required.md

@@ -0,0 +1,6 @@
+# AIKit Skills — No MCP server required
+
+These skills are plain Bash + Read/Write — they call `casen` directly and never depend on an MCP server or a running proxy. The `@bpmnkit/proxy` MCP server (`bpmn-aikit`) still exists separately, for Claude Desktop/Cursor or other MCP-only hosts — it's unrelated to these slash commands.
+
+---
+Source: https://docs.bpmnkit.com/cli/skills/