bland-cli 0.1.2

package/dist/commands/pathway.js

@@ -0,0 +1,1003 @@
+import { input, select, confirm, editor } from "@inquirer/prompts";
+import chalk from "chalk";
+import ora from "ora";
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "yaml";
+import { api, extractArray } from "../lib/api.js";
+import * as output from "../lib/output.js";
+import { handleError } from "../lib/errors.js";
+import { readPathwayFile, writePathwayFile, findPathwayFile, apiToFile, fileToApi, createStarterPathway, createStarterTestCases, } from "../lib/pathway-file.js";
+import { writeProjectConfig, readProjectConfig } from "../lib/config.js";
+import * as readline from "readline";
+export function registerPathwayCommand(program) {
+    const pathway = program
+        .command("pathway")
+        .description("Manage and develop conversational pathways");
+    // ──────────────────────────────────────
+    //  CRUD
+    // ──────────────────────────────────────
+    // ── bland pathway list ──
+    pathway
+        .command("list")
+        .description("List all pathways")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        try {
+            const spinner = ora("Fetching pathways...").start();
+            const raw = await api.get("/v1/convo_pathway");
+            spinner.stop();
+            const pathways = extractArray(raw);
+            if (opts.json) {
+                output.json(pathways);
+                return;
+            }
+            if (pathways.length === 0) {
+                console.log(chalk.dim("  No pathways found."));
+                return;
+            }
+            output.table(pathways.map((p) => ({
+                ...p,
+                published: p.published_at ? chalk.green("live") : chalk.dim("draft"),
+                version: p.production_version_number ?? chalk.dim("—"),
+            })), [
+                { key: "id", header: "ID", width: 38 },
+                { key: "name", header: "Name", width: 34 },
+                { key: "published", header: "Status", width: 8 },
+                { key: "version", header: "Version", width: 9 },
+            ]);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+    // ── bland pathway get ──
+    pathway
+        .command("get")
+        .description("Get pathway details")
+        .argument("<id>", "Pathway ID")
+        .option("--json", "Output as JSON")
+        .action(async (id, opts) => {
+        try {
+            const spinner = ora("Fetching pathway...").start();
+            const pw = await api.get(`/v1/convo_pathway/${id}`);
+            spinner.stop();
+            if (opts.json) {
+                output.json(pw);
+                return;
+            }
+            console.log();
+            output.detail([
+                ["ID", pw.id],
+                ["Name", pw.name],
+                ["Description", pw.description || "—"],
+                ["Nodes", pw.nodes?.length || 0],
+                ["Edges", pw.edges?.length || 0],
+                ["Created", output.formatDate(pw.created_at)],
+                ["Updated", output.formatDate(pw.updated_at)],
+            ]);
+            if (pw.nodes && pw.nodes.length > 0) {
+                output.header("Nodes");
+                output.table(pw.nodes.filter((n) => n.data).map((n) => ({
+                    id: n.id,
+                    name: n.data.name || n.id,
+                    type: n.data.type || "default",
+                    prompt: n.data.prompt
+                        ? output.truncate(n.data.prompt, 50)
+                        : chalk.dim("—"),
+                    global: n.data.isGlobal ? chalk.cyan("global") : "",
+                })), [
+                    { key: "name", header: "Name", width: 25 },
+                    { key: "type", header: "Type", width: 15 },
+                    { key: "prompt", header: "Prompt", width: 52 },
+                    { key: "global", header: "", width: 8 },
+                ]);
+            }
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+    // ── bland pathway create ──
+    pathway
+        .command("create")
+        .description("Create a new pathway")
+        .argument("[name]", "Pathway name")
+        .option("--from-file <path>", "Create from local YAML/JSON file")
+        .option("--json", "Output as JSON")
+        .action(async (nameArg, opts) => {
+        try {
+            let name = nameArg;
+            if (opts.fromFile) {
+                const file = readPathwayFile(opts.fromFile);
+                name = name || file.name;
+                const apiData = fileToApi(file);
+                apiData.name = name;
+                const spinner = ora("Creating pathway...").start();
+                const result = await api.post("/v1/convo_pathway", apiData);
+                spinner.succeed(`Pathway "${name}" created ${chalk.dim(`(${result.id})`)}`);
+                if (opts.json)
+                    output.json(result);
+                return;
+            }
+            if (!name) {
+                name = await input({
+                    message: "Pathway name:",
+                    validate: (v) => v.trim().length > 0 || "Name is required",
+                });
+            }
+            const spinner = ora("Creating pathway...").start();
+            const result = await api.post("/v1/convo_pathway", {
+                name,
+                nodes: [],
+                edges: [],
+            });
+            spinner.succeed(`Pathway "${name}" created ${chalk.dim(`(${result.id})`)}`);
+            if (opts.json)
+                output.json(result);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+    // ── bland pathway delete ──
+    pathway
+        .command("delete")
+        .description("Delete a pathway")
+        .argument("<id>", "Pathway ID")
+        .action(async (id) => {
+        try {
+            const proceed = await confirm({
+                message: `Delete pathway ${id}? This cannot be undone.`,
+            });
+            if (!proceed)
+                return;
+            const spinner = ora("Deleting pathway...").start();
+            await api.delete(`/v1/convo_pathway/${id}`);
+            spinner.succeed("Pathway deleted.");
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+    // ── bland pathway duplicate ──
+    pathway
+        .command("duplicate")
+        .description("Duplicate a pathway")
+        .argument("<id>", "Pathway ID to duplicate")
+        .option("--name <name>", "Name for the copy")
+        .option("--json", "Output as JSON")
+        .action(async (id, opts) => {
+        try {
+            const spinner = ora("Duplicating pathway...").start();
+            const body = { pathway_id: id };
+            if (opts.name)
+                body.name = opts.name;
+            const result = await api.post("/v1/convo_pathway/duplicate", body);
+            spinner.succeed(`Duplicated as "${result.name}" ${chalk.dim(`(${result.id})`)}`);
+            if (opts.json)
+                output.json(result);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+    // ──────────────────────────────────────
+    //  LOCAL FILE WORKFLOW
+    // ──────────────────────────────────────
+    // ── bland pathway init ──
+    pathway
+        .command("init")
+        .description("Initialize a local pathway project")
+        .argument("[dir]", "Directory to initialize", ".")
+        .option("--name <name>", "Pathway name")
+        .action(async (dir, opts) => {
+        try {
+            const targetDir = path.resolve(dir);
+            let name = opts.name;
+            if (!name) {
+                name = await input({
+                    message: "Pathway name:",
+                    default: path.basename(targetDir),
+                    validate: (v) => v.trim().length > 0 || "Name is required",
+                });
+            }
+            // Create directory structure
+            if (!fs.existsSync(targetDir)) {
+                fs.mkdirSync(targetDir, { recursive: true });
+            }
+            const testsDir = path.join(targetDir, "tests");
+            if (!fs.existsSync(testsDir)) {
+                fs.mkdirSync(testsDir, { recursive: true });
+            }
+            // Create pathway file
+            const pathwayFilePath = path.join(targetDir, "bland-pathway.yaml");
+            if (!fs.existsSync(pathwayFilePath)) {
+                const starterPathway = createStarterPathway(name);
+                writePathwayFile(pathwayFilePath, starterPathway);
+            }
+            // Create test cases file
+            const testFilePath = path.join(testsDir, "test-cases.yaml");
+            if (!fs.existsSync(testFilePath)) {
+                const starterTests = createStarterTestCases(name);
+                fs.writeFileSync(testFilePath, yaml.stringify(starterTests), "utf-8");
+            }
+            // Create project config
+            writeProjectConfig({
+                pathway_file: "bland-pathway.yaml",
+                test_file: "tests/test-cases.yaml",
+            }, targetDir);
+            output.success(`Initialized pathway project in ${targetDir}`);
+            console.log();
+            console.log(`  ${chalk.dim("├──")} bland-pathway.yaml`);
+            console.log(`  ${chalk.dim("├──")} tests/`);
+            console.log(`  ${chalk.dim("│   └──")} test-cases.yaml`);
+            console.log(`  ${chalk.dim("└──")} .blandrc`);
+            console.log();
+            console.log(chalk.dim("  Edit bland-pathway.yaml, then run `bland pathway push` to upload."));
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+    // ── bland pathway pull ──
+    pathway
+        .command("pull")
+        .description("Download a pathway as local YAML files")
+        .argument("<id>", "Pathway ID")
+        .argument("[dir]", "Target directory", ".")
+        .option("--format <fmt>", "File format: yaml or json", "yaml")
+        .action(async (id, dir, opts) => {
+        try {
+            const spinner = ora("Fetching pathway...").start();
+            const pw = await api.get(`/v1/convo_pathway/${id}`);
+            spinner.stop();
+            const targetDir = path.resolve(dir);
+            if (!fs.existsSync(targetDir)) {
+                fs.mkdirSync(targetDir, { recursive: true });
+            }
+            const file = apiToFile(pw);
+            const ext = opts.format === "json" ? ".json" : ".yaml";
+            const filePath = path.join(targetDir, `bland-pathway${ext}`);
+            writePathwayFile(filePath, file);
+            // Save project config
+            writeProjectConfig({
+                pathway_id: id,
+                pathway_file: `bland-pathway${ext}`,
+            }, targetDir);
+            output.success(`Pulled "${pw.name}" to ${filePath}`);
+            console.log(chalk.dim(`  ${pw.nodes?.length || 0} nodes, ${pw.edges?.length || 0} edges`));
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+    // ── bland pathway push ──
+    pathway
+        .command("push")
+        .description("Upload local pathway files to Bland")
+        .argument("[dir]", "Directory with pathway files", ".")
+        .option("--create", "Create new pathway if no ID is linked")
+        .option("--publish", "Promote to production after pushing")
+        .option("--version <v>", "Set version label (e.g. v1.0, draft, production)")
+        .option("--json", "Output as JSON")
+        .action(async (dir, opts) => {
+        try {
+            const targetDir = path.resolve(dir);
+            const projectConfig = readProjectConfig(targetDir);
+            const pathwayFilePath = findPathwayFile(targetDir) ||
+                (projectConfig?.pathway_file
+                    ? path.join(targetDir, projectConfig.pathway_file)
+                    : null);
+            if (!pathwayFilePath) {
+                console.error(chalk.red("No pathway file found. Run `bland pathway init` first."));
+                process.exit(1);
+            }
+            const file = readPathwayFile(pathwayFilePath);
+            const apiData = fileToApi(file);
+            // Attach version if provided
+            if (opts.version) {
+                apiData.version = opts.version;
+            }
+            const spinner = ora("Pushing pathway...").start();
+            let pathwayId;
+            let result;
+            if (projectConfig?.pathway_id) {
+                // Update existing
+                pathwayId = projectConfig.pathway_id;
+                result = await api.post(`/v1/convo_pathway/${pathwayId}`, apiData);
+                spinner.succeed(`Updated "${file.name}" ${chalk.dim(`(${pathwayId})`)}`);
+            }
+            else if (opts.create) {
+                // Create new
+                result = await api.post("/v1/convo_pathway", apiData);
+                pathwayId = result.id;
+                writeProjectConfig({ ...projectConfig, pathway_id: pathwayId }, targetDir);
+                spinner.succeed(`Created "${file.name}" ${chalk.dim(`(${pathwayId})`)}`);
+            }
+            else {
+                spinner.fail("No pathway ID linked.");
+                console.log(chalk.dim("  Use --create to create a new pathway, or `bland pathway pull <id>` to link an existing one."));
+                process.exit(1);
+            }
+            console.log(chalk.dim(`  ${apiData.nodes.length} nodes, ${apiData.edges.length} edges`));
+            // Promote to production if requested
+            if (opts.publish) {
+                const promoteSpinner = ora("Promoting to production...").start();
+                try {
+                    await api.post(`/v1/convo_pathway/${pathwayId}/promote`, {
+                        pathway_id: pathwayId,
+                    });
+                    promoteSpinner.succeed("Promoted to production.");
+                }
+                catch (promoteErr) {
+                    promoteSpinner.fail("Failed to promote.");
+                    handleError(promoteErr);
+                }
+            }
+            if (opts.json)
+                output.json(result);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+    // ── bland pathway diff ──
+    pathway
+        .command("diff")
+        .description("Show diff between local and remote pathway")
+        .argument("[dir]", "Directory with pathway files", ".")
+        .action(async (dir) => {
+        try {
+            const targetDir = path.resolve(dir);
+            const projectConfig = readProjectConfig(targetDir);
+            if (!projectConfig?.pathway_id) {
+                console.error(chalk.red("No pathway ID linked. Run `bland pathway pull <id>` first."));
+                process.exit(1);
+            }
+            const pathwayFilePath = findPathwayFile(targetDir);
+            if (!pathwayFilePath) {
+                console.error(chalk.red("No pathway file found."));
+                process.exit(1);
+            }
+            const spinner = ora("Comparing...").start();
+            const localFile = readPathwayFile(pathwayFilePath);
+            const remotePw = await api.get(`/v1/convo_pathway/${projectConfig.pathway_id}`);
+            const remoteFile = apiToFile(remotePw);
+            spinner.stop();
+            const localYaml = yaml.stringify(localFile);
+            const remoteYaml = yaml.stringify(remoteFile);
+            if (localYaml === remoteYaml) {
+                output.success("Local and remote are in sync.");
+                return;
+            }
+            console.log();
+            console.log(chalk.bold("Differences found:"));
+            console.log();
+            // Compare node names
+            const localNodes = new Set(Object.keys(localFile.nodes));
+            const remoteNodes = new Set(Object.keys(remoteFile.nodes));
+            for (const node of localNodes) {
+                if (!remoteNodes.has(node)) {
+                    console.log(chalk.green(`  + Node "${node}" (local only)`));
+                }
+            }
+            for (const node of remoteNodes) {
+                if (!localNodes.has(node)) {
+                    console.log(chalk.red(`  - Node "${node}" (remote only)`));
+                }
+            }
+            // Compare shared nodes
+            for (const node of localNodes) {
+                if (remoteNodes.has(node)) {
+                    const localNode = localFile.nodes[node];
+                    const remoteNode = remoteFile.nodes[node];
+                    if (yaml.stringify(localNode) !== yaml.stringify(remoteNode)) {
+                        console.log(chalk.yellow(`  ~ Node "${node}" differs`));
+                        // Show prompt diff if different
+                        if (localNode.prompt !== remoteNode.prompt) {
+                            console.log(chalk.dim(`    prompt changed`));
+                        }
+                        if (JSON.stringify(localNode.edges) !==
+                            JSON.stringify(remoteNode.edges)) {
+                            console.log(chalk.dim(`    edges changed`));
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+    // ── bland pathway validate ──
+    pathway
+        .command("validate")
+        .description("Validate local pathway files")
+        .argument("[dir]", "Directory with pathway files", ".")
+        .action(async (dir) => {
+        try {
+            const targetDir = path.resolve(dir);
+            const pathwayFilePath = findPathwayFile(targetDir);
+            if (!pathwayFilePath) {
+                console.error(chalk.red("No pathway file found."));
+                process.exit(1);
+            }
+            const file = readPathwayFile(pathwayFilePath);
+            const nodeCount = Object.keys(file.nodes).length;
+            // Count total edges
+            let edgeCount = 0;
+            let toolCount = 0;
+            for (const node of Object.values(file.nodes)) {
+                edgeCount += node.edges?.length || 0;
+                toolCount += node.tools?.length || 0;
+            }
+            output.success(`${nodeCount} nodes, ${edgeCount} edges, ${toolCount} tools — all valid`);
+        }
+        catch (err) {
+            // readPathwayFile throws BlandError on validation failures
+            handleError(err);
+        }
+    });
+    // ── bland pathway watch ──
+    pathway
+        .command("watch")
+        .description("Watch for changes and auto-push")
+        .argument("[dir]", "Directory to watch", ".")
+        .action(async (dir) => {
+        try {
+            const targetDir = path.resolve(dir);
+            const projectConfig = readProjectConfig(targetDir);
+            if (!projectConfig?.pathway_id) {
+                console.error(chalk.red("No pathway ID linked. Run `bland pathway pull <id>` first."));
+                process.exit(1);
+            }
+            const pathwayFilePath = findPathwayFile(targetDir);
+            if (!pathwayFilePath) {
+                console.error(chalk.red("No pathway file found."));
+                process.exit(1);
+            }
+            console.log(`Watching ${chalk.bold(pathwayFilePath)} for changes...`);
+            console.log(chalk.dim("Press Ctrl+C to stop."));
+            console.log();
+            // Use fs.watch for simplicity (avoids chokidar dependency at runtime for now)
+            let debounceTimer = null;
+            fs.watch(pathwayFilePath, () => {
+                if (debounceTimer)
+                    clearTimeout(debounceTimer);
+                debounceTimer = setTimeout(async () => {
+                    const ts = new Date().toLocaleTimeString();
+                    process.stdout.write(`${chalk.dim(`[${ts}]`)} File changed → pushing... `);
+                    try {
+                        const file = readPathwayFile(pathwayFilePath);
+                        const apiData = fileToApi(file);
+                        await api.post(`/v1/convo_pathway/${projectConfig.pathway_id}`, apiData);
+                        console.log(chalk.green("✓"));
+                    }
+                    catch (err) {
+                        console.log(chalk.red("✗"));
+                        console.error(chalk.red(`  ${err instanceof Error ? err.message : "Push failed"}`));
+                    }
+                }, 500);
+            });
+            // Keep process alive
+            await new Promise(() => { });
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+    // ──────────────────────────────────────
+    //  INTERACTIVE EDITING
+    // ──────────────────────────────────────
+    // ── bland pathway edit ──
+    pathway
+        .command("edit")
+        .description("Edit a pathway node's prompt interactively")
+        .argument("<id>", "Pathway ID")
+        .action(async (id) => {
+        try {
+            const spinner = ora("Fetching pathway...").start();
+            const pw = await api.get(`/v1/convo_pathway/${id}`);
+            spinner.stop();
+            if (!pw.nodes || pw.nodes.length === 0) {
+                console.log(chalk.dim("  Pathway has no nodes."));
+                return;
+            }
+            const nodeChoice = await select({
+                message: "Select node to edit:",
+                choices: pw.nodes.filter((n) => n.data).map((n) => ({
+                    name: `${n.data.name || n.id} ${chalk.dim(`(${n.data.type || "default"})`)}`,
+                    value: n.id,
+                })),
+            });
+            const node = pw.nodes.find((n) => n.id === nodeChoice);
+            if (!node)
+                return;
+            console.log();
+            console.log(chalk.bold(`Editing node: ${node.data.name || node.id}`));
+            console.log(chalk.dim("Current prompt:"));
+            console.log(chalk.dim(node.data.prompt || "(empty)"));
+            console.log();
+            const newPrompt = await editor({
+                message: "Edit prompt (opens in $EDITOR):",
+                default: node.data.prompt || "",
+            });
+            if (newPrompt.trim() === (node.data.prompt || "").trim()) {
+                console.log(chalk.dim("  No changes made."));
+                return;
+            }
+            node.data.prompt = newPrompt.trim();
+            const updateSpinner = ora("Updating pathway...").start();
+            await api.post(`/v1/convo_pathway/${id}`, {
+                nodes: pw.nodes,
+                edges: pw.edges,
+            });
+            updateSpinner.succeed("Node prompt updated.");
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+    // ──────────────────────────────────────
+    //  TESTING & SIMULATION
+    // ──────────────────────────────────────
+    // ── bland pathway chat ──
+    pathway
+        .command("chat")
+        .description("Interactive text chat with a pathway")
+        .argument("<id>", "Pathway ID")
+        .option("--start-node <node_id>", "Start at specific node")
+        .option("--variables <json>", "Inject variables (JSON)")
+        .option("--version <v>", "Pathway version")
+        .option("--verbose", "Show node transitions and tool calls")
+        .action(async (id, opts) => {
+        try {
+            // Create chat session
+            const chatBody = {
+                pathway_id: id,
+            };
+            if (opts.startNode)
+                chatBody.start_node_id = opts.startNode;
+            if (opts.version)
+                chatBody.pathway_version = opts.version;
+            if (opts.variables) {
+                try {
+                    chatBody.request_data = JSON.parse(opts.variables);
+                }
+                catch {
+                    console.error(chalk.red("Error: --variables must be valid JSON"));
+                    process.exit(1);
+                }
+            }
+            const spinner = ora("Creating chat session...").start();
+            const session = await api.post("/v1/pathway/chat", chatBody);
+            spinner.stop();
+            console.log();
+            console.log(chalk.bold(`Chat with pathway ${chalk.dim(`(${id})`)}`));
+            console.log(chalk.dim("Type your messages. Ctrl+C to exit."));
+            console.log();
+            // Interactive REPL
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const chat = async (userMessage) => {
+                try {
+                    const response = await api.post(`/v1/pathway/chat/${session.chat_id}`, { message: userMessage });
+                    if (opts.verbose && response.current_node) {
+                        console.log(chalk.dim(`  ─── Node: ${response.current_node} ───`));
+                    }
+                    if (opts.verbose && response.variables) {
+                        const vars = Object.entries(response.variables);
+                        if (vars.length > 0) {
+                            for (const [k, v] of vars) {
+                                console.log(chalk.dim(`  ─── Extracted: ${k} = ${JSON.stringify(v)} ───`));
+                            }
+                        }
+                    }
+                    console.log(`  ${chalk.cyan("Agent")}: ${response.message}`);
+                    console.log();
+                }
+                catch (err) {
+                    console.error(chalk.red(`  Error: ${err instanceof Error ? err.message : "Chat failed"}`));
+                }
+            };
+            const askQuestion = () => {
+                rl.question(chalk.green("You: "), async (answer) => {
+                    if (!answer.trim()) {
+                        askQuestion();
+                        return;
+                    }
+                    await chat(answer.trim());
+                    askQuestion();
+                });
+            };
+            askQuestion();
+            // Handle Ctrl+C
+            rl.on("close", () => {
+                console.log();
+                console.log(chalk.dim("  Chat ended."));
+                process.exit(0);
+            });
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+    // ── bland pathway test ──
+    pathway
+        .command("test")
+        .description("Run test cases against a pathway")
+        .argument("<id>", "Pathway ID")
+        .option("--file <path>", "Test case file (YAML)")
+        .option("--json", "Output as JSON")
+        .action(async (id, opts) => {
+        try {
+            let testFile = opts.file;
+            if (!testFile) {
+                const projectConfig = readProjectConfig();
+                if (projectConfig?.test_file) {
+                    testFile = projectConfig.test_file;
+                }
+                else {
+                    // Try default location
+                    const defaultPath = path.join("tests", "test-cases.yaml");
+                    if (fs.existsSync(defaultPath)) {
+                        testFile = defaultPath;
+                    }
+                }
+            }
+            if (!testFile || !fs.existsSync(testFile)) {
+                console.error(chalk.red("No test file found. Use --file or create tests/test-cases.yaml"));
+                process.exit(1);
+            }
+            const content = fs.readFileSync(testFile, "utf-8");
+            const testData = yaml.parse(content);
+            const tests = testData.tests || [];
+            if (tests.length === 0) {
+                console.log(chalk.dim("  No test cases found."));
+                return;
+            }
+            console.log(`Running ${chalk.bold(tests.length)} test case(s)...`);
+            console.log();
+            const results = [];
+            for (const test of tests) {
+                const start = Date.now();
+                process.stdout.write(`  ${chalk.dim("⠋")} ${test.name}...`);
+                try {
+                    // Create chat session for test
+                    const session = await api.post("/v1/pathway/chat", { pathway_id: id });
+                    // Send scenario as first message
+                    const response = await api.post(`/v1/pathway/chat/${session.chat_id}`, { message: test.scenario });
+                    const duration = (Date.now() - start) / 1000;
+                    // Basic validation: check if we got a response
+                    const passed = !!response.message;
+                    results.push({
+                        name: test.name,
+                        passed,
+                        duration,
+                    });
+                    const icon = passed ? chalk.green("✓") : chalk.red("✗");
+                    process.stdout.write(`\r  ${icon} ${test.name} ${chalk.dim(`(${duration.toFixed(1)}s)`)}\n`);
+                }
+                catch (err) {
+                    const duration = (Date.now() - start) / 1000;
+                    const errorMsg = err instanceof Error ? err.message : "Unknown error";
+                    results.push({
+                        name: test.name,
+                        passed: false,
+                        duration,
+                        error: errorMsg,
+                    });
+                    process.stdout.write(`\r  ${chalk.red("✗")} ${test.name} ${chalk.dim(`(${duration.toFixed(1)}s)`)} — ${chalk.red(errorMsg)}\n`);
+                }
+            }
+            const passed = results.filter((r) => r.passed).length;
+            const total = results.length;
+            console.log();
+            if (passed === total) {
+                output.success(`${passed}/${total} passed`);
+            }
+            else {
+                console.log(chalk.red(`  ${passed}/${total} passed`));
+            }
+            if (opts.json)
+                output.json(results);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+    // ── bland pathway simulate ──
+    pathway
+        .command("simulate")
+        .description("Run AI simulation on a pathway")
+        .argument("<id>", "Pathway ID")
+        .option("--scenario <text>", "Scenario description")
+        .option("--count <n>", "Number of simulations", "1")
+        .option("--json", "Output as JSON")
+        .action(async (id, opts) => {
+        try {
+            const spinner = ora("Starting simulation...").start();
+            const body = {
+                pathway_id: id,
+                count: parseInt(opts.count, 10),
+            };
+            if (opts.scenario)
+                body.scenario = opts.scenario;
+            const result = await api.post("/v1/pathway/simulations", body);
+            spinner.succeed(`Simulation started ${chalk.dim(`(${result.simulation_id})`)}`);
+            if (opts.json)
+                output.json(result);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+    // ── bland pathway promote ──
+    pathway
+        .command("promote")
+        .description("Promote pathway draft to production")
+        .argument("<id>", "Pathway ID")
+        .option("--version <v>", "Specific version to promote")
+        .action(async (id, opts) => {
+        try {
+            const proceed = await confirm({
+                message: `Promote pathway ${id} to production?`,
+            });
+            if (!proceed)
+                return;
+            const spinner = ora("Promoting to production...").start();
+            const body = { pathway_id: id };
+            if (opts.version)
+                body.version = opts.version;
+            await api.post(`/v1/convo_pathway/${id}/promote`, body);
+            spinner.succeed("Promoted to production.");
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+    // ── bland pathway versions ──
+    pathway
+        .command("versions")
+        .description("List pathway versions")
+        .argument("<id>", "Pathway ID")
+        .option("--json", "Output as JSON")
+        .action(async (id, opts) => {
+        try {
+            const spinner = ora("Fetching versions...").start();
+            const rawVersions = await api.get(`/v1/convo_pathway/${id}/versions`);
+            spinner.stop();
+            const versions = extractArray(rawVersions);
+            if (opts.json) {
+                output.json(versions);
+                return;
+            }
+            if (versions.length === 0) {
+                console.log(chalk.dim("  No versions found."));
+                return;
+            }
+            output.json(versions);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+    // ── bland pathway generate ──
+    pathway
+        .command("generate")
+        .description("AI-generate a pathway from a description")
+        .option("--description <text>", "What the pathway should do")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        try {
+            let description = opts.description;
+            if (!description) {
+                description = await input({
+                    message: "Describe what the pathway should do:",
+                    validate: (v) => v.trim().length > 0 || "Description is required",
+                });
+            }
+            const spinner = ora("Generating pathway...").start();
+            const result = await api.post("/v1/pathway/generate", { description });
+            spinner.succeed(`Generated "${result.name}" ${chalk.dim(`(${result.id})`)}`);
+            if (opts.json)
+                output.json(result);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+    // ──────────────────────────────────────
+    //  NODE-LEVEL COMMANDS
+    // ──────────────────────────────────────
+    const node = pathway
+        .command("node")
+        .description("Manage individual pathway nodes");
+    // ── bland pathway node list ──
+    node
+        .command("list")
+        .description("List all nodes in a pathway")
+        .argument("<pathway_id>", "Pathway ID")
+        .option("--json", "Output as JSON")
+        .action(async (pathwayId, opts) => {
+        try {
+            const spinner = ora("Fetching nodes...").start();
+            const pw = await api.get(`/v1/convo_pathway/${pathwayId}`);
+            spinner.stop();
+            if (opts.json) {
+                output.json(pw.nodes);
+                return;
+            }
+            if (!pw.nodes || pw.nodes.length === 0) {
+                console.log(chalk.dim("  No nodes."));
+                return;
+            }
+            output.table(pw.nodes.filter((n) => n.data).map((n) => ({
+                id: n.id,
+                name: n.data.name || n.id,
+                type: n.data.type || "default",
+                prompt: n.data.prompt
+                    ? output.truncate(n.data.prompt, 60)
+                    : chalk.dim("—"),
+                vars: n.data.extractVars?.length || 0,
+                global: n.data.isGlobal ? "yes" : "",
+            })), [
+                { key: "name", header: "Name", width: 25 },
+                { key: "type", header: "Type", width: 15 },
+                { key: "prompt", header: "Prompt", width: 62 },
+                { key: "vars", header: "Vars", width: 6 },
+                { key: "global", header: "Global", width: 8 },
+            ]);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+    // ── bland pathway node test ──
+    node
+        .command("test")
+        .description("Test an individual node")
+        .argument("<pathway_id>", "Pathway ID")
+        .argument("<node_id>", "Node ID")
+        .option("--prompt <text>", "Override node prompt")
+        .option("--conversation <call_id>", "Use real call as context")
+        .option("--permutations <n>", "Number of variations", "5")
+        .option("--version <v>", "Pathway version")
+        .option("--json", "Output as JSON")
+        .action(async (pathwayId, nodeId, opts) => {
+        try {
+            const spinner = ora("Running node test...").start();
+            const body = {
+                pathway_id: pathwayId,
+                node_id: nodeId,
+                n_permutations: parseInt(opts.permutations, 10),
+            };
+            if (opts.prompt)
+                body.new_prompt = opts.prompt;
+            if (opts.version)
+                body.pathway_version = opts.version;
+            if (opts.conversation) {
+                body.conversations = [
+                    { id: opts.conversation, type: "call" },
+                ];
+            }
+            const result = await api.post("/v1/node_tests/run", body);
+            spinner.succeed(`Node test started ${chalk.dim(`(run_id: ${result.run_id})`)}`);
+            if (opts.json)
+                output.json(result);
+            console.log(chalk.dim("  Use `bland pathway node test-results <run_id>` to check results."));
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+    // ──────────────────────────────────────
+    //  CODE TOOL TESTING
+    // ──────────────────────────────────────
+    const code = pathway
+        .command("code")
+        .description("Test custom code nodes");
+    // ── bland pathway code test ──
+    code
+        .command("test")
+        .description("Test a custom code node in isolation")
+        .argument("<pathway_id>", "Pathway ID")
+        .argument("<node_id>", "Node ID")
+        .option("--input <json>", "Test input data (JSON)")
+        .option("--json", "Output as JSON")
+        .action(async (pathwayId, nodeId, opts) => {
+        try {
+            let testInput = {};
+            if (opts.input) {
+                try {
+                    testInput = JSON.parse(opts.input);
+                }
+                catch {
+                    console.error(chalk.red("Error: --input must be valid JSON"));
+                    process.exit(1);
+                }
+            }
+            const spinner = ora("Executing custom code...").start();
+            const start = Date.now();
+            const result = await api.post(`/v1/blandcode/test`, {
+                pathway_id: pathwayId,
+                node_id: nodeId,
+                input: testInput,
+            });
+            const duration = Date.now() - start;
+            spinner.stop();
+            if (opts.json) {
+                output.json({ ...result, duration_ms: duration });
+                return;
+            }
+            if (result.error) {
+                console.log(chalk.red(`  Error: ${result.error}`));
+            }
+            else {
+                output.header("Input");
+                console.log(`  ${JSON.stringify(testInput, null, 2).split("\n").join("\n  ")}`);
+                output.header("Output");
+                console.log(`  ${JSON.stringify(result.output, null, 2).split("\n").join("\n  ")}`);
+                if (result.logs && result.logs.length > 0) {
+                    output.header("Logs");
+                    for (const log of result.logs) {
+                        console.log(`  ${chalk.dim(log)}`);
+                    }
+                }
+                output.header("Execution Time");
+                console.log(`  ${duration}ms`);
+                console.log();
+                output.success("Code executed successfully");
+            }
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+    // ──────────────────────────────────────
+    //  FOLDERS
+    // ──────────────────────────────────────
+    const folder = pathway
+        .command("folder")
+        .description("Manage pathway folders");
+    folder
+        .command("list")
+        .description("List pathway folders")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        try {
+            const spinner = ora("Fetching folders...").start();
+            const raw = await api.get("/v1/pathway/folders");
+            spinner.stop();
+            const folders = extractArray(raw);
+            if (opts.json) {
+                output.json(folders);
+                return;
+            }
+            output.json(folders);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+    folder
+        .command("create")
+        .description("Create a pathway folder")
+        .argument("<name>", "Folder name")
+        .action(async (name) => {
+        try {
+            const spinner = ora("Creating folder...").start();
+            const result = await api.post("/v1/pathway/folders", {
+                name,
+            });
+            spinner.succeed(`Folder "${name}" created ${chalk.dim(`(${result.id})`)}`);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+}
+//# sourceMappingURL=pathway.js.map