@bpmnkit/cli 0.0.22 → 0.0.24

package/README.md

@@ -108,6 +108,8 @@ casen instances list --state active
 | [`@bpmnkit/operate`](https://www.npmjs.com/package/@bpmnkit/operate) | Monitoring & operations frontend for Camunda clusters |
 | [`@bpmnkit/connector-gen`](https://www.npmjs.com/package/@bpmnkit/connector-gen) | Generate connector templates from OpenAPI specs |
 | [`@bpmnkit/proxy`](https://www.npmjs.com/package/@bpmnkit/proxy) | Local AI bridge and Camunda API proxy server |
+| [`@bpmnkit/patterns`](https://www.npmjs.com/package/@bpmnkit/patterns) | Domain process patterns for BPMNKit AIKit |
+| [`@bpmnkit/worker-client`](https://www.npmjs.com/package/@bpmnkit/worker-client) | Thin Zeebe REST client for standalone workers |
 | [`@bpmnkit/cli-sdk`](https://www.npmjs.com/package/@bpmnkit/cli-sdk) | Plugin authoring SDK for the casen CLI |
 | [`@bpmnkit/create-casen-plugin`](https://www.npmjs.com/package/@bpmnkit/create-casen-plugin) | Scaffold a new casen CLI plugin in seconds |
 | [`@bpmnkit/casen-report`](https://www.npmjs.com/package/@bpmnkit/casen-report) | HTML reports from Camunda 8 incident and SLA data |

package/dist/commands/index.js

@@ -7,10 +7,14 @@ import { connectorGroup } from "./connector.js";
 import { lintGroup } from "./lint.js";
 import { pluginGroup } from "./plugin.js";
 import { profileGroup } from "./profile.js";
+import { proxyGroup } from "./proxy.js";
+import { reebeGroup } from "./reebe.js";
 import { computeRelations } from "./relations.js";
 import { settingsGroup } from "./settings.js";
+import { skillsGroup } from "./skills.js";
 import { storyGroup } from "./story.js";
 import { testGroup } from "./test.js";
+import { workerStartCmd } from "./worker-start.js";
 import { workerCmd } from "./worker.js";
 // Inject custom commands into generated groups without modifying generated files.
 // Also remove the broken generated get-x-m-l commands (return text/xml, not JSON)
@@ -45,13 +49,16 @@ const sortedOtherGroups = [
 ].sort((a, b) => a.name.localeCompare(b.name));
 const workerGroup = {
     name: "worker",
-    description: workerCmd.description,
-    commands: [workerCmd],
+    description: "Run job workers — auto-complete (casen worker <type>) or start scaffolded workers (casen worker start)",
+    commands: [workerCmd, workerStartCmd],
 };
 /** Pinned groups shown above the separator in the main TUI menu. */
 export const pinnedGroups = [
     askGroup,
     lintGroup,
+    proxyGroup,
+    reebeGroup,
+    skillsGroup,
     storyGroup,
     settingsGroup,
     testGroup,

package/dist/commands/proxy.js

@@ -0,0 +1,33 @@
+import { startServer } from "@bpmnkit/proxy";
+const startCmd = {
+    name: "start",
+    description: "Start the BPMN Kit proxy server (AI bridge + Camunda API proxy)",
+    flags: [
+        {
+            name: "port",
+            description: "Port to listen on",
+            type: "number",
+            default: 3033,
+        },
+    ],
+    examples: [
+        { description: "Start on default port (3033)", command: "casen proxy start" },
+        { description: "Start on a custom port", command: "casen proxy start --port 4000" },
+    ],
+    async run(ctx) {
+        const port = ctx.flags.port ?? 3033;
+        ctx.output.info(`Starting BPMN Kit proxy server on port ${port}...`);
+        startServer(port);
+        // Keep the CLI alive until the user presses Ctrl+C
+        await new Promise((resolve) => {
+            process.once("SIGINT", resolve);
+            process.once("SIGTERM", resolve);
+        });
+    },
+};
+export const proxyGroup = {
+    name: "proxy",
+    description: "Start the local AI bridge and Camunda API proxy server",
+    commands: [startCmd],
+};
+//# sourceMappingURL=proxy.js.map

package/dist/commands/reebe.js

@@ -0,0 +1,77 @@
+import { spawn } from "node:child_process";
+const startCmd = {
+    name: "start",
+    description: "Start the Reebe workflow engine (Zeebe-compatible REST API)",
+    flags: [
+        {
+            name: "port",
+            description: "HTTP port to listen on",
+            type: "number",
+            default: 8080,
+        },
+        {
+            name: "database-url",
+            description: "PostgreSQL database URL. Omit to use embedded SQLite (no external database required).",
+            type: "string",
+            placeholder: "postgres://user:pass@host/db",
+        },
+        {
+            name: "config",
+            description: "Path to config.toml",
+            type: "string",
+            default: "config.toml",
+            placeholder: "PATH",
+        },
+    ],
+    examples: [
+        {
+            description: "Start with embedded SQLite (no external database required)",
+            command: "casen reebe start",
+        },
+        {
+            description: "Start with PostgreSQL",
+            command: "casen reebe start --database-url postgres://user:pass@localhost/reebe",
+        },
+        { description: "Start on a custom port", command: "casen reebe start --port 9090" },
+    ],
+    async run(ctx) {
+        const port = ctx.flags.port ?? 8080;
+        const dbUrl = ctx.flags["database-url"];
+        const configPath = ctx.flags.config ?? "config.toml";
+        ctx.output.info(`Starting Reebe workflow engine on port ${port}...`);
+        ctx.output.info(dbUrl ? `Database: ${dbUrl}` : "Database: embedded SQLite");
+        ctx.output.info("Press Ctrl+C to stop\n");
+        const args = ["--port", String(port), "--config", configPath];
+        const env = { ...process.env, REEBE_PORT: String(port) };
+        if (dbUrl)
+            env.REEBE_DATABASE_URL = dbUrl;
+        await new Promise((resolve, reject) => {
+            const child = spawn("reebe-server", args, { stdio: "inherit", env });
+            child.on("error", (err) => {
+                const code = err.code;
+                if (code === "ENOENT") {
+                    reject(new Error([
+                        "reebe-server not found.",
+                        "Build from source:",
+                        "  cargo install --path apps/reebe/crates/reebe-server",
+                    ].join("\n")));
+                }
+                else {
+                    reject(err);
+                }
+            });
+            child.on("close", (exitCode) => {
+                if (exitCode === 0 || exitCode === null)
+                    resolve();
+                else
+                    reject(new Error(`Reebe engine exited with code ${exitCode}`));
+            });
+        });
+    },
+};
+export const reebeGroup = {
+    name: "reebe",
+    description: "Start the Reebe workflow engine (drop-in Zeebe replacement, ~50 MB)",
+    commands: [startCmd],
+};
+//# sourceMappingURL=reebe.js.map

package/dist/commands/skills.js

@@ -0,0 +1,74 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+ * Install BPMNKit AIKit skills into `.claude/commands/` in the current project.
+ * Skills are markdown prompt files that Claude Code executes as slash commands:
+ *   /implement, /review, /test, /deploy
+ */
+const skillsInstallCmd = {
+    name: "install",
+    description: "Install BPMNKit AIKit slash commands into .claude/commands/",
+    args: [],
+    flags: [
+        {
+            name: "force",
+            short: "f",
+            description: "Overwrite existing skill files",
+            type: "boolean",
+        },
+    ],
+    examples: [
+        { description: "Install AIKit skills", command: "casen skills install" },
+        {
+            description: "Reinstall and overwrite existing skills",
+            command: "casen skills install --force",
+        },
+    ],
+    async run(ctx) {
+        const force = ctx.flags.force === true;
+        // Locate the bundled skills directory relative to this binary
+        // Installed layout: dist/index.js → ../skills/<name>.md
+        const binDir = fileURLToPath(new URL(".", import.meta.url));
+        const skillsSrc = join(binDir, "..", "skills");
+        if (!existsSync(skillsSrc)) {
+            throw new Error(`Bundled skills directory not found at: ${skillsSrc}`);
+        }
+        const skillFiles = readdirSync(skillsSrc).filter((f) => f.endsWith(".md"));
+        if (skillFiles.length === 0) {
+            throw new Error("No skill files found in bundled skills directory");
+        }
+        const destDir = join(process.cwd(), ".claude", "commands");
+        mkdirSync(destDir, { recursive: true });
+        let installed = 0;
+        let skipped = 0;
+        for (const file of skillFiles) {
+            const dest = join(destDir, file);
+            if (existsSync(dest) && !force) {
+                ctx.output.info(`  skip  ${file} (already exists — use --force to overwrite)`);
+                skipped++;
+                continue;
+            }
+            const content = readFileSync(join(skillsSrc, file), "utf8");
+            writeFileSync(dest, content, "utf8");
+            ctx.output.ok(`  wrote ${file}`);
+            installed++;
+        }
+        ctx.output.info("");
+        ctx.output.ok(`Installed ${installed} skill(s)${skipped > 0 ? `, skipped ${skipped}` : ""} → .claude/commands/`);
+        ctx.output.info("");
+        ctx.output.info("Available slash commands in Claude Code:");
+        for (const file of skillFiles) {
+            const name = file.replace(/\.md$/, "");
+            ctx.output.info(`  /${name}`);
+        }
+        ctx.output.info("");
+        ctx.output.info("Make sure the BPMNKit AIKit MCP server is configured in .claude/mcp.json");
+    },
+};
+export const skillsGroup = {
+    name: "skills",
+    description: "Manage BPMNKit AIKit slash commands for Claude Code",
+    commands: [skillsInstallCmd],
+};
+//# sourceMappingURL=skills.js.map

package/dist/commands/worker-start.js

@@ -0,0 +1,80 @@
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Start scaffolded workers from the ./workers/ directory.
+ * Workers must have a package.json with a `bpmnkit.jobType` field (written by worker_scaffold).
+ * Runs `npm start` in each worker directory — workers use tsx for development convenience.
+ */
+export const workerStartCmd = {
+    name: "start",
+    description: "Start scaffolded workers from the ./workers/ directory",
+    args: [
+        {
+            name: "name",
+            description: "Worker name to start (default: start all workers)",
+            required: false,
+        },
+    ],
+    flags: [],
+    examples: [
+        { description: "Start all scaffolded workers", command: "casen worker start" },
+        { description: "Start a specific worker", command: "casen worker start send-invoice" },
+    ],
+    async run(ctx) {
+        const filterName = ctx.positional[0];
+        const workersDir = join(process.cwd(), "workers");
+        if (!existsSync(workersDir)) {
+            ctx.output.info("No workers/ directory found. Use the /implement skill or worker_scaffold MCP tool to create workers.");
+            return;
+        }
+        // Discover scaffolded workers (those with bpmnkit.jobType in their package.json)
+        const entries = readdirSync(workersDir, { withFileTypes: true })
+            .filter((e) => e.isDirectory())
+            .filter((e) => {
+            const pkgPath = join(workersDir, e.name, "package.json");
+            if (!existsSync(pkgPath))
+                return false;
+            try {
+                const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+                return Boolean(pkg.bpmnkit?.jobType);
+            }
+            catch {
+                return false;
+            }
+        });
+        if (entries.length === 0) {
+            ctx.output.info("No scaffolded workers found in workers/");
+            return;
+        }
+        const toStart = filterName ? entries.filter((e) => e.name === filterName) : entries;
+        if (filterName && toStart.length === 0) {
+            throw new Error(`Worker "${filterName}" not found in workers/`);
+        }
+        ctx.output.info(`Starting ${toStart.length} worker(s) — press Ctrl+C to stop`);
+        ctx.output.info("");
+        for (const entry of toStart) {
+            const workerDir = join(workersDir, entry.name);
+            // Read job type for display
+            let jobType = entry.name;
+            try {
+                const pkg = JSON.parse(readFileSync(join(workerDir, "package.json"), "utf8"));
+                jobType = pkg.bpmnkit?.jobType ?? entry.name;
+            }
+            catch {
+                /* ignore */
+            }
+            ctx.output.info(`  [${entry.name}] starting — job type: ${jobType}`);
+            const child = spawn("npm", ["start"], {
+                cwd: workerDir,
+                stdio: "inherit",
+                shell: true,
+            });
+            child.on("error", (err) => {
+                process.stderr.write(`[${entry.name}] failed to start: ${err.message}\n` +
+                    `  Did you run \`npm install\` in workers/${entry.name}/?\n`);
+            });
+        }
+    },
+};
+//# sourceMappingURL=worker-start.js.map

package/dist/run.js

@@ -102,9 +102,34 @@ export async function run(argv) {
         process.exitCode = 1;
         return;
     }
-    // ── worker: treat positional[1] as the job type argument ─────────────────
+    // ── proxy / reebe: run start directly when no subcommand is given ────────
+    if ((group.name === "proxy" || group.name === "reebe") && positional.length === 1 && !wantHelp) {
+        const output = createOutputWriter(outputFormat, noColor);
+        const ctx = { positional: [], flags, output, getClient, getAdminClient };
+        const cmd = group.commands[0];
+        if (cmd)
+            await cmd.run(ctx);
+        return;
+    }
+    // ── worker: route `casen worker start [name]` or treat positional[1] as job type ──
     if (group.name === "worker" && positional.length >= 2 && !wantHelp) {
         const output = createOutputWriter(outputFormat, noColor);
+        // `casen worker start [name]` → route to the start command
+        if (positional[1] === "start") {
+            const startCmd = group.commands.find((c) => c.name === "start");
+            if (startCmd) {
+                const ctx = {
+                    positional: positional.slice(2),
+                    flags,
+                    output,
+                    getClient,
+                    getAdminClient,
+                };
+                await startCmd.run(ctx);
+                return;
+            }
+        }
+        // Legacy: treat positional[1] as the job type argument for the auto-complete worker
         const ctx = {
             positional: positional.slice(1),
             flags,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bpmnkit/cli",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "description": "Command-line interface for Camunda 8 — deploy, manage, and monitor processes from the terminal",
   "type": "module",
   "bin": {
@@ -9,18 +9,20 @@
   "files": [
     "LICENSE",
     "README.md",
-    "dist/**/*.js"
+    "dist/**/*.js",
+    "skills/**/*.md"
   ],
   "engines": {
     "node": ">=20"
   },
   "dependencies": {
-    "@bpmnkit/api": "0.0.16",
-    "@bpmnkit/ascii": "0.0.20",
-    "@bpmnkit/connector-gen": "0.0.11",
-    "@bpmnkit/core": "0.0.20",
-    "@bpmnkit/profiles": "0.0.14",
-    "@bpmnkit/engine": "0.1.19"
+    "@bpmnkit/api": "0.0.17",
+    "@bpmnkit/ascii": "0.0.21",
+    "@bpmnkit/connector-gen": "0.0.12",
+    "@bpmnkit/core": "0.0.21",
+    "@bpmnkit/engine": "0.1.20",
+    "@bpmnkit/profiles": "0.0.15",
+    "@bpmnkit/proxy": "0.0.22"
   },
   "publishConfig": {
     "access": "public"

package/skills/deploy.md

@@ -0,0 +1,31 @@
+---
+description: Deploy a BPMN process to local reebe or Camunda 8
+---
+
+Deploy the BPMN process at the given path.
+
+## File to deploy
+
+$ARGUMENTS
+
+---
+
+1. Call `mcp__bpmnkit-aikit__bpmn_validate` on the file to check for errors before deploying.
+   - If there are errors, show them and ask: **"Fix errors first or deploy anyway?"**
+   - If warnings only: show them but proceed.
+
+2. Ask: **"Deploy to local reebe or Camunda 8?"**
+
+3. Call `mcp__bpmnkit-aikit__bpmn_deploy` with the chosen target:
+   - `"local"` — deploys to the local reebe instance at ZEEBE_ADDRESS
+   - `"camunda8"` — deploys using the active casen profile (run `casen profile create` if not set up)
+
+4. Report the result:
+   - On success: "Deployed successfully. Process ID: <id>"
+   - On failure: show the error and suggest a fix (profile not set up, reebe not running, etc.)
+
+5. If any scaffolded workers exist in ./workers/, remind:
+   ```
+   Don't forget to start your workers:
+     casen worker start
+   ```

package/skills/implement.md

@@ -0,0 +1,91 @@
+---
+description: Implement a BPMN process end-to-end from a natural language description
+---
+
+You are implementing a BPMN process end-to-end using BPMNKit AIKit tools. Work through these steps in order.
+
+## Request
+
+$ARGUMENTS
+
+---
+
+## Step 1 — Check for a domain pattern
+
+Call `mcp__bpmnkit-aikit__pattern_list` to see available domain patterns.
+If any pattern keywords match the request, call `mcp__bpmnkit-aikit__pattern_get` to load the full pattern as context for the next step.
+
+---
+
+## Step 2 — Plan: Create the BPMN
+
+Spawn a subagent with this task:
+
+> Using the MCP tool `mcp__bpmnkit-aikit__bpmn_create`, generate a BPMN process for: **$ARGUMENTS**
+>
+> If a domain pattern was loaded in Step 1, pass its readme and worker specs as additional context in the description parameter.
+>
+> Return the file path of the generated BPMN.
+
+---
+
+## Step 3 — Implement: Wire workers
+
+Spawn a subagent with this task:
+
+> You are implementing workers for a BPMN process.
+>
+> 1. Call `mcp__bpmnkit-aikit__worker_list` to get the catalog of available workers.
+> 2. Call `mcp__bpmnkit-aikit__bpmn_read` on the BPMN file from Step 2 to find all service task job types.
+> 3. For each service task job type:
+>    - If a built-in or previously scaffolded worker matches: note it as "reused"
+>    - If no match exists: call `mcp__bpmnkit-aikit__worker_scaffold` with the job type, a description, and expected inputs/outputs derived from the BPMN context
+> 4. Return: a list of `{ jobType, status: "reused" | "scaffolded", workerPath? }` for each service task
+
+---
+
+## Step 4 — Review: Validate the BPMN
+
+Spawn a subagent with this task:
+
+> Call `mcp__bpmnkit-aikit__bpmn_validate` on the BPMN file from Step 2.
+> Identify any errors that block deployment and any warnings worth noting.
+> Return: `{ errors: [...], warnings: [...] }`
+
+---
+
+## Step 5 — Test: Check coverage
+
+Spawn a subagent with this task:
+
+> Call `mcp__bpmnkit-aikit__bpmn_simulate` on the BPMN file from Step 2 with an empty scenarios array.
+> Return: worker coverage report (total service tasks, covered, missing)
+
+---
+
+## Step 6 — Present summary and ask to deploy
+
+Collect all results and present a summary:
+
+```
+BPMN file: <path>
+Pattern used: <id or "none">
+
+Workers:
+  ✓ reused:     <list>
+  + scaffolded: <list with paths>
+
+Validation:
+  Errors:   <count> — <list if any>
+  Warnings: <count> — <list if any>
+
+Worker coverage: <covered>/<total> service tasks
+
+Scaffolded workers require: npm install && npm start (in each workers/<name>/ directory)
+```
+
+Then ask: **"Deploy to local reebe, deploy to Camunda 8, or skip deployment?"**
+
+- If "local": call `mcp__bpmnkit-aikit__bpmn_deploy` with `target: "local"`
+- If "camunda8": call `mcp__bpmnkit-aikit__bpmn_deploy` with `target: "camunda8"`
+- If "skip": done

package/skills/review.md

@@ -0,0 +1,33 @@
+---
+description: Review a BPMN file and report findings with severity and fix suggestions
+---
+
+Review the BPMN file at the given path using BPMNKit's pattern advisor.
+
+## File to review
+
+$ARGUMENTS
+
+---
+
+1. Call `mcp__bpmnkit-aikit__bpmn_validate` on the path above.
+
+2. Present findings grouped by severity:
+
+**Errors** (block deployment or indicate broken process flow)
+- For each error: element IDs, message, suggested fix
+
+**Warnings** (best-practice violations, missing patterns)
+- For each warning: element IDs, message, suggested fix
+
+**Info** (improvement suggestions)
+- For each info item: message
+
+3. Show a summary:
+```
+Total: <n> findings — <errors> errors, <warnings> warnings, <info> info
+Auto-fixable: <n>
+```
+
+4. If there are auto-fixable findings, ask: **"Apply auto-fixes?"**
+   If yes, call `mcp__bpmnkit-aikit__bpmn_update` with instruction: "Apply all auto-fixable pattern advisor suggestions"

package/skills/test.md

@@ -0,0 +1,36 @@
+---
+description: Analyse a BPMN process — check worker coverage and validation findings
+---
+
+Analyse the BPMN process at the given path.
+
+## File to test
+
+$ARGUMENTS
+
+---
+
+1. Call `mcp__bpmnkit-aikit__bpmn_read` to understand the process structure (elements, service tasks, gateways, event types).
+
+2. Call `mcp__bpmnkit-aikit__bpmn_simulate` with the path and an empty scenarios array to get worker coverage and validation analysis.
+
+3. Call `mcp__bpmnkit-aikit__worker_list` to show the full worker catalog.
+
+4. Present the results:
+
+**Process structure**
+- Pools / participants
+- Service tasks and their job types
+- Decision gateways and branch conditions
+- Event types (timer, message, error, escalation)
+
+**Worker coverage**
+- ✓ Covered job types (matched to built-in or scaffolded workers)
+- ✗ Missing job types (no worker found — scaffold with worker_scaffold)
+
+**Validation findings**
+- Errors and warnings from the pattern advisor
+
+**Suggested test scenarios** (derived from the BPMN structure)
+- Happy path: <describe the main success path>
+- Edge cases: <describe key branches, timeouts, error conditions>