primitive-admin 1.0.0

package/dist/src/commands/prompts.js

@@ -0,0 +1,999 @@
+import { readFileSync } from "fs";
+import * as TOML from "@iarna/toml";
+import { ApiClient } from "../lib/api-client.js";
+import { getCurrentAppId } from "../lib/config.js";
+import chalk from "chalk";
+import { success, error, info, keyValue, formatTable, formatId, formatDate, formatStatus, formatDuration, json, divider, } from "../lib/output.js";
+function resolveAppId(appId, options) {
+    const resolved = appId || options.app || getCurrentAppId();
+    if (!resolved) {
+        error("No app specified. Use <app-id>, --app, or 'primitive use <app-id>' to set context.");
+        process.exit(1);
+    }
+    return resolved;
+}
+export function registerPromptsCommands(program) {
+    const prompts = program
+        .command("prompts")
+        .description("Configure LLM prompts, manage variations, and test execution")
+        .addHelpText("after", `
+Examples:
+  $ primitive prompts list
+  $ primitive prompts create --from-file summarizer.toml
+  $ primitive prompts execute 01HXY... --vars '{"text":"Hello world"}'
+  $ primitive prompts configs activate 01HXY... 01ABC...
+`);
+    // List prompts
+    prompts
+        .command("list")
+        .description("List prompts")
+        .argument("[app-id]", "App ID (uses current app if not specified)")
+        .option("--app <app-id>", "App ID")
+        .option("--status <status>", "Filter by status: draft, active, archived")
+        .option("--json", "Output as JSON")
+        .action(async (appId, options) => {
+        const resolvedAppId = resolveAppId(appId, options);
+        const client = new ApiClient();
+        try {
+            const { items } = await client.listPrompts(resolvedAppId, {
+                status: options.status,
+            });
+            if (options.json) {
+                json(items);
+                return;
+            }
+            if (!items || items.length === 0) {
+                info("No prompts found.");
+                return;
+            }
+            console.log(formatTable(items, [
+                { header: "ID", key: "promptId", format: formatId },
+                { header: "KEY", key: "promptKey" },
+                { header: "NAME", key: "displayName" },
+                { header: "STATUS", key: "status", format: formatStatus },
+                { header: "MODIFIED", key: "modifiedAt", format: formatDate },
+            ]));
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Create prompt
+    prompts
+        .command("create")
+        .description("Create a new prompt")
+        .argument("[app-id]", "App ID (uses current app if not specified)")
+        .option("--app <app-id>", "App ID")
+        .option("--key <key>", "Prompt key (unique identifier)")
+        .option("--name <name>", "Display name")
+        .option("--description <desc>", "Description")
+        .option("--provider <provider>", "LLM provider: openrouter, gemini", "openrouter")
+        .option("--model <model>", "Model name")
+        .option("--system-prompt <prompt>", "System prompt")
+        .option("--user-template <template>", "User prompt template")
+        .option("--temperature <temp>", "Temperature (0-1)")
+        .option("--max-tokens <n>", "Max output tokens")
+        .option("--input-schema <json>", "Input schema as JSON")
+        .option("--from-file <path>", "Load prompt from TOML file")
+        .option("--json", "Output as JSON")
+        .action(async (appId, options) => {
+        const resolvedAppId = resolveAppId(appId, options);
+        const client = new ApiClient();
+        let payload;
+        if (options.fromFile) {
+            try {
+                const content = readFileSync(options.fromFile, "utf-8");
+                const tomlData = TOML.parse(content);
+                const prompt = tomlData.prompt || tomlData;
+                const config = tomlData.configs?.[0] || {};
+                payload = {
+                    promptKey: prompt.key || prompt.promptKey,
+                    displayName: prompt.displayName || prompt.name,
+                    description: prompt.description,
+                    provider: config.provider || prompt.provider || "openrouter",
+                    model: config.model || prompt.model,
+                    systemPrompt: config.systemPrompt || prompt.systemPrompt,
+                    userPromptTemplate: config.userPromptTemplate || prompt.userPromptTemplate,
+                    temperature: config.temperature || prompt.temperature,
+                    maxTokens: config.maxTokens || prompt.maxTokens,
+                    inputSchema: prompt.inputSchema,
+                };
+            }
+            catch (err) {
+                error(`Failed to read TOML file: ${err.message}`);
+                process.exit(1);
+            }
+        }
+        else {
+            if (!options.key || !options.name || !options.model || !options.userTemplate) {
+                error("Required: --key, --name, --model, --user-template (or use --from-file)");
+                process.exit(1);
+            }
+            payload = {
+                promptKey: options.key,
+                displayName: options.name,
+                description: options.description,
+                provider: options.provider,
+                model: options.model,
+                systemPrompt: options.systemPrompt,
+                userPromptTemplate: options.userTemplate,
+                temperature: options.temperature,
+                maxTokens: options.maxTokens ? parseInt(options.maxTokens) : undefined,
+                inputSchema: options.inputSchema,
+            };
+        }
+        try {
+            const result = await client.createPrompt(resolvedAppId, payload);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            success(`Prompt created: ${result.displayName}`);
+            keyValue("Prompt ID", result.promptId);
+            keyValue("Key", result.promptKey);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Get prompt
+    prompts
+        .command("get")
+        .description("Get prompt details")
+        .argument("<prompt-id>", "Prompt ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--json", "Output as JSON")
+        .action(async (promptId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const result = await client.getPrompt(resolvedAppId, promptId);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            keyValue("Prompt ID", result.promptId);
+            keyValue("Key", result.promptKey);
+            keyValue("Name", result.displayName);
+            keyValue("Description", result.description);
+            keyValue("Status", formatStatus(result.status));
+            keyValue("Active Config", result.activeConfigId || "-");
+            if (result.configs && result.configs.length > 0) {
+                divider();
+                info(`Configs (${result.configs.length}):`);
+                console.log(formatTable(result.configs, [
+                    { header: "ID", key: "configId", format: formatId },
+                    { header: "NAME", key: "configName" },
+                    { header: "MODEL", key: "model" },
+                    { header: "STATUS", key: "status", format: formatStatus },
+                ]));
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Update prompt
+    prompts
+        .command("update")
+        .description("Update a prompt")
+        .argument("<prompt-id>", "Prompt ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--name <name>", "Display name")
+        .option("--description <desc>", "Description")
+        .option("--status <status>", "Status: draft, active, archived")
+        .option("--input-schema <json>", "Input schema as JSON")
+        .option("--json", "Output as JSON")
+        .action(async (promptId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const payload = {};
+        if (options.name)
+            payload.displayName = options.name;
+        if (options.description)
+            payload.description = options.description;
+        if (options.status)
+            payload.status = options.status;
+        if (options.inputSchema)
+            payload.inputSchema = options.inputSchema;
+        if (Object.keys(payload).length === 0) {
+            error("No update options specified.");
+            process.exit(1);
+        }
+        const client = new ApiClient();
+        try {
+            const result = await client.updatePrompt(resolvedAppId, promptId, payload);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            success("Prompt updated.");
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Delete prompt
+    prompts
+        .command("delete")
+        .description("Delete or archive a prompt")
+        .argument("<prompt-id>", "Prompt ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--hard", "Permanently delete instead of archive")
+        .option("-y, --yes", "Skip confirmation prompt")
+        .action(async (promptId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        if (!options.yes) {
+            const action = options.hard ? "permanently delete" : "archive";
+            const inquirer = await import("inquirer");
+            const { confirm } = await inquirer.default.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Are you sure you want to ${action} prompt ${promptId}?`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                info("Cancelled.");
+                return;
+            }
+        }
+        const client = new ApiClient();
+        try {
+            await client.deletePrompt(resolvedAppId, promptId, options.hard);
+            success(`Prompt ${options.hard ? "deleted" : "archived"}.`);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Execute prompt
+    prompts
+        .command("execute")
+        .description("Execute a prompt with variables")
+        .argument("<prompt-id>", "Prompt ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--vars <json>", "Input variables as JSON")
+        .option("--config <config-id>", "Specific config ID to use")
+        .option("--json", "Output as JSON")
+        .action(async (promptId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        let variables = {};
+        if (options.vars) {
+            try {
+                variables = JSON.parse(options.vars);
+            }
+            catch {
+                error("Invalid JSON in --vars");
+                process.exit(1);
+            }
+        }
+        const client = new ApiClient();
+        try {
+            const result = await client.executePrompt(resolvedAppId, promptId, {
+                variables,
+                configId: options.config,
+            });
+            if (options.json) {
+                json(result);
+                return;
+            }
+            if (result.success) {
+                success("Execution successful");
+                keyValue("Duration", formatDuration(result.metrics?.durationMs));
+                keyValue("Tokens", `${result.metrics?.inputTokens || 0} in / ${result.metrics?.outputTokens || 0} out`);
+                console.log("\nOutput:");
+                console.log(result.output);
+            }
+            else {
+                error(`Execution failed: ${result.error}`);
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Preview prompt
+    prompts
+        .command("preview")
+        .description("Preview rendered prompt without executing")
+        .argument("<prompt-id>", "Prompt ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--vars <json>", "Input variables as JSON")
+        .option("--config <config-id>", "Specific config ID to use")
+        .option("--json", "Output as JSON")
+        .action(async (promptId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        let variables = {};
+        if (options.vars) {
+            try {
+                variables = JSON.parse(options.vars);
+            }
+            catch {
+                error("Invalid JSON in --vars");
+                process.exit(1);
+            }
+        }
+        const client = new ApiClient();
+        try {
+            const result = await client.previewPrompt(resolvedAppId, promptId, {
+                variables,
+                configId: options.config,
+            });
+            if (options.json) {
+                json(result);
+                return;
+            }
+            keyValue("Provider", result.provider);
+            keyValue("Model", result.model);
+            if (result.systemPrompt) {
+                console.log("\nSystem Prompt:");
+                console.log(result.systemPrompt);
+            }
+            console.log("\nUser Prompt:");
+            console.log(result.userPrompt);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Configs subcommand
+    const configs = prompts.command("configs").description("Manage prompt configs");
+    // List configs
+    configs
+        .command("list")
+        .description("List configs for a prompt")
+        .argument("<prompt-id>", "Prompt ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--json", "Output as JSON")
+        .action(async (promptId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const { items } = await client.listPromptConfigs(resolvedAppId, promptId);
+            if (options.json) {
+                json(items);
+                return;
+            }
+            if (!items || items.length === 0) {
+                info("No configs found.");
+                return;
+            }
+            console.log(formatTable(items, [
+                { header: "ID", key: "configId", format: formatId },
+                { header: "NAME", key: "configName" },
+                { header: "PROVIDER", key: "provider" },
+                { header: "MODEL", key: "model" },
+                { header: "STATUS", key: "status", format: formatStatus },
+            ]));
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Create config
+    configs
+        .command("create")
+        .description("Create a new config for a prompt")
+        .argument("<prompt-id>", "Prompt ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--name <name>", "Config name")
+        .option("--description <desc>", "Description")
+        .option("--provider <provider>", "LLM provider: openrouter, gemini", "openrouter")
+        .option("--model <model>", "Model name")
+        .option("--system-prompt <prompt>", "System prompt")
+        .option("--user-template <template>", "User prompt template")
+        .option("--temperature <temp>", "Temperature (0-1)")
+        .option("--max-tokens <n>", "Max output tokens")
+        .option("--json", "Output as JSON")
+        .action(async (promptId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        if (!options.name || !options.model || !options.userTemplate) {
+            error("Required: --name, --model, --user-template");
+            process.exit(1);
+        }
+        const payload = {
+            configName: options.name,
+            description: options.description,
+            provider: options.provider,
+            model: options.model,
+            systemPrompt: options.systemPrompt,
+            userPromptTemplate: options.userTemplate,
+            temperature: options.temperature,
+            maxTokens: options.maxTokens ? parseInt(options.maxTokens) : undefined,
+        };
+        const client = new ApiClient();
+        try {
+            const result = await client.createPromptConfig(resolvedAppId, promptId, payload);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            success(`Config created: ${result.configName}`);
+            keyValue("Config ID", result.configId);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Activate config
+    configs
+        .command("activate")
+        .description("Set a config as the active config for a prompt")
+        .argument("<prompt-id>", "Prompt ID")
+        .argument("<config-id>", "Config ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .action(async (promptId, configId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            await client.activatePromptConfig(resolvedAppId, promptId, configId);
+            success(`Config ${configId} activated.`);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Duplicate config
+    configs
+        .command("duplicate")
+        .description("Duplicate a config")
+        .argument("<prompt-id>", "Prompt ID")
+        .argument("<config-id>", "Config ID to duplicate")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--name <name>", "New config name")
+        .option("--json", "Output as JSON")
+        .action(async (promptId, configId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const result = await client.duplicatePromptConfig(resolvedAppId, promptId, configId, {
+                configName: options.name,
+            });
+            if (options.json) {
+                json(result);
+                return;
+            }
+            success(`Config duplicated: ${result.configName}`);
+            keyValue("New Config ID", result.configId);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Update config
+    configs
+        .command("update")
+        .description("Update a config")
+        .argument("<prompt-id>", "Prompt ID")
+        .argument("<config-id>", "Config ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--name <name>", "Config name")
+        .option("--description <desc>", "Description")
+        .option("--provider <provider>", "LLM provider: openrouter, gemini")
+        .option("--model <model>", "Model name")
+        .option("--system-prompt <prompt>", "System prompt")
+        .option("--user-template <template>", "User prompt template")
+        .option("--temperature <temp>", "Temperature (0-1)")
+        .option("--max-tokens <n>", "Max output tokens")
+        .option("--status <status>", "Status: active, archived")
+        .option("--json", "Output as JSON")
+        .action(async (promptId, configId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const payload = {};
+        if (options.name)
+            payload.configName = options.name;
+        if (options.description)
+            payload.description = options.description;
+        if (options.provider)
+            payload.provider = options.provider;
+        if (options.model)
+            payload.model = options.model;
+        if (options.systemPrompt)
+            payload.systemPrompt = options.systemPrompt;
+        if (options.userTemplate)
+            payload.userPromptTemplate = options.userTemplate;
+        if (options.temperature)
+            payload.temperature = options.temperature;
+        if (options.maxTokens)
+            payload.maxTokens = parseInt(options.maxTokens);
+        if (options.status)
+            payload.status = options.status;
+        if (Object.keys(payload).length === 0) {
+            error("No update options specified.");
+            process.exit(1);
+        }
+        const client = new ApiClient();
+        try {
+            const result = await client.updatePromptConfig(resolvedAppId, promptId, configId, payload);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            success("Config updated.");
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // ============================================
+    // TESTS SUBCOMMAND
+    // ============================================
+    const tests = prompts
+        .command("tests")
+        .description("Manage and run prompt test cases")
+        .addHelpText("after", `
+Examples:
+  $ primitive prompts tests list <prompt-id>
+  $ primitive prompts tests create <prompt-id> --name "Basic test" --vars '{"input":"hello"}'
+  $ primitive prompts tests run <prompt-id> <test-case-id>
+  $ primitive prompts tests run-all <prompt-id>
+`);
+    // List test cases
+    tests
+        .command("list")
+        .description("List test cases for a prompt")
+        .argument("<prompt-id>", "Prompt ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--json", "Output as JSON")
+        .action(async (promptId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const { items } = await client.listTestCases(resolvedAppId, "prompt", promptId);
+            if (options.json) {
+                json(items);
+                return;
+            }
+            if (!items || items.length === 0) {
+                info("No test cases found.");
+                return;
+            }
+            console.log(formatTable(items, [
+                { header: "ID", key: "testCaseId", format: formatId },
+                { header: "NAME", key: "name" },
+                { header: "CONFIG", key: "configId", format: (v) => v ? formatId(v) : "-" },
+                { header: "CREATED", key: "createdAt", format: formatDate },
+            ]));
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Create test case
+    tests
+        .command("create")
+        .description("Create a test case for a prompt")
+        .argument("<prompt-id>", "Prompt ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--name <name>", "Test case name (required)")
+        .option("--vars <json>", "Input variables as JSON (required)")
+        .option("--pattern <regex>", "Expected output pattern (regex)")
+        .option("--contains <json>", "Expected strings to contain (JSON array)")
+        .option("--json-subset <json>", "Expected JSON subset to match")
+        .option("--config <config-id>", "Config ID to use for this test")
+        .option("--evaluator-prompt <prompt-id>", "Evaluator prompt ID")
+        .option("--evaluator-config <config-id>", "Evaluator config ID")
+        .option("--json", "Output as JSON")
+        .action(async (promptId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        if (!options.name || !options.vars) {
+            error("Required: --name and --vars");
+            process.exit(1);
+        }
+        let inputVariables;
+        try {
+            inputVariables = JSON.parse(options.vars);
+        }
+        catch {
+            error("Invalid JSON in --vars");
+            process.exit(1);
+        }
+        let expectedOutputContains;
+        if (options.contains) {
+            try {
+                expectedOutputContains = JSON.parse(options.contains);
+            }
+            catch {
+                error("Invalid JSON in --contains");
+                process.exit(1);
+            }
+        }
+        let expectedJsonSubset;
+        if (options.jsonSubset) {
+            try {
+                expectedJsonSubset = JSON.parse(options.jsonSubset);
+            }
+            catch {
+                error("Invalid JSON in --json-subset");
+                process.exit(1);
+            }
+        }
+        const client = new ApiClient();
+        try {
+            const result = await client.createTestCase(resolvedAppId, "prompt", promptId, {
+                name: options.name,
+                inputVariables,
+                expectedOutputPattern: options.pattern,
+                expectedOutputContains,
+                expectedJsonSubset,
+                configId: options.config,
+                evaluatorPromptId: options.evaluatorPrompt,
+                evaluatorConfigId: options.evaluatorConfig,
+            });
+            if (options.json) {
+                json(result);
+                return;
+            }
+            success(`Test case created: ${result.name}`);
+            keyValue("Test Case ID", result.testCaseId);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Get test case
+    tests
+        .command("get")
+        .description("Get test case details")
+        .argument("<prompt-id>", "Prompt ID")
+        .argument("<test-case-id>", "Test Case ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--json", "Output as JSON")
+        .action(async (promptId, testCaseId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const result = await client.getTestCase(resolvedAppId, "prompt", promptId, testCaseId);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            keyValue("Test Case ID", result.testCaseId);
+            keyValue("Name", result.name);
+            keyValue("Config ID", result.configId || "-");
+            keyValue("Created", formatDate(result.createdAt));
+            divider();
+            info("Input Variables:");
+            try {
+                const vars = JSON.parse(result.inputVariables || "{}");
+                console.log(JSON.stringify(vars, null, 2));
+            }
+            catch {
+                console.log(result.inputVariables || "{}");
+            }
+            if (result.expectedOutputPattern) {
+                divider();
+                keyValue("Expected Pattern", result.expectedOutputPattern);
+            }
+            if (result.expectedOutputContains) {
+                divider();
+                info("Expected Contains:");
+                try {
+                    console.log(JSON.stringify(JSON.parse(result.expectedOutputContains), null, 2));
+                }
+                catch {
+                    console.log(result.expectedOutputContains);
+                }
+            }
+            if (result.expectedJsonSubset) {
+                divider();
+                info("Expected JSON Subset:");
+                try {
+                    console.log(JSON.stringify(JSON.parse(result.expectedJsonSubset), null, 2));
+                }
+                catch {
+                    console.log(result.expectedJsonSubset);
+                }
+            }
+            if (result.evaluatorPromptId) {
+                divider();
+                keyValue("Evaluator Prompt", result.evaluatorPromptId);
+                keyValue("Evaluator Config", result.evaluatorConfigId || "-");
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Update test case
+    tests
+        .command("update")
+        .description("Update a test case")
+        .argument("<prompt-id>", "Prompt ID")
+        .argument("<test-case-id>", "Test Case ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--name <name>", "Test case name")
+        .option("--vars <json>", "Input variables as JSON")
+        .option("--pattern <regex>", "Expected output pattern (regex)")
+        .option("--contains <json>", "Expected strings to contain (JSON array)")
+        .option("--json-subset <json>", "Expected JSON subset to match")
+        .option("--config <config-id>", "Config ID to use for this test")
+        .option("--clear-pattern", "Clear expected pattern")
+        .option("--clear-contains", "Clear expected contains")
+        .option("--clear-json-subset", "Clear expected JSON subset")
+        .option("--json", "Output as JSON")
+        .action(async (promptId, testCaseId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const payload = {};
+        if (options.name)
+            payload.name = options.name;
+        if (options.vars) {
+            try {
+                payload.inputVariables = JSON.parse(options.vars);
+            }
+            catch {
+                error("Invalid JSON in --vars");
+                process.exit(1);
+            }
+        }
+        if (options.clearPattern) {
+            payload.expectedOutputPattern = null;
+        }
+        else if (options.pattern) {
+            payload.expectedOutputPattern = options.pattern;
+        }
+        if (options.clearContains) {
+            payload.expectedOutputContains = null;
+        }
+        else if (options.contains) {
+            try {
+                payload.expectedOutputContains = JSON.parse(options.contains);
+            }
+            catch {
+                error("Invalid JSON in --contains");
+                process.exit(1);
+            }
+        }
+        if (options.clearJsonSubset) {
+            payload.expectedJsonSubset = null;
+        }
+        else if (options.jsonSubset) {
+            try {
+                payload.expectedJsonSubset = JSON.parse(options.jsonSubset);
+            }
+            catch {
+                error("Invalid JSON in --json-subset");
+                process.exit(1);
+            }
+        }
+        if (options.config)
+            payload.configId = options.config;
+        if (Object.keys(payload).length === 0) {
+            error("No update options specified.");
+            process.exit(1);
+        }
+        const client = new ApiClient();
+        try {
+            const result = await client.updateTestCase(resolvedAppId, "prompt", promptId, testCaseId, payload);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            success("Test case updated.");
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Delete test case
+    tests
+        .command("delete")
+        .description("Delete a test case")
+        .argument("<prompt-id>", "Prompt ID")
+        .argument("<test-case-id>", "Test Case ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("-y, --yes", "Skip confirmation prompt")
+        .action(async (promptId, testCaseId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        if (!options.yes) {
+            const inquirer = await import("inquirer");
+            const { confirm } = await inquirer.default.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Are you sure you want to delete test case ${testCaseId}?`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                info("Cancelled.");
+                return;
+            }
+        }
+        const client = new ApiClient();
+        try {
+            await client.deleteTestCase(resolvedAppId, "prompt", promptId, testCaseId);
+            success("Test case deleted.");
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Run a single test case
+    tests
+        .command("run")
+        .description("Run a single test case")
+        .argument("<prompt-id>", "Prompt ID")
+        .argument("<test-case-id>", "Test Case ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--config <config-id>", "Override config ID")
+        .option("--json", "Output as JSON")
+        .action(async (promptId, testCaseId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            // Get test case to retrieve its variables
+            const testCase = await client.getTestCase(resolvedAppId, "prompt", promptId, testCaseId);
+            let variables = {};
+            try {
+                variables = JSON.parse(testCase.inputVariables || "{}");
+            }
+            catch {
+                // Use empty object if parsing fails
+            }
+            const result = await client.executeBlockTest(resolvedAppId, "prompt", promptId, {
+                variables,
+                testCaseId,
+                configId: options.config || testCase.configId,
+            });
+            if (options.json) {
+                json(result);
+                return;
+            }
+            const passed = result.verification?.passed;
+            if (passed) {
+                success("Test PASSED");
+            }
+            else {
+                error("Test FAILED");
+            }
+            keyValue("Duration", formatDuration(result.metrics?.durationMs));
+            keyValue("Tokens", `${result.metrics?.inputTokens || 0} in / ${result.metrics?.outputTokens || 0} out`);
+            if (result.verification) {
+                divider();
+                info("Verification:");
+                const v = result.verification;
+                keyValue("  Passed", v.passed ? chalk.green("Yes") : chalk.red("No"));
+                keyValue("  Checks", `${v.summary?.passed || 0}/${v.summary?.total || 0} passed`);
+                if (v.checks && v.checks.length > 0) {
+                    console.log();
+                    for (const check of v.checks) {
+                        const icon = check.passed ? chalk.green("✓") : chalk.red("✗");
+                        console.log(`  ${icon} ${check.name}`);
+                        if (!check.passed && check.message) {
+                            console.log(`    ${chalk.dim(check.message)}`);
+                        }
+                    }
+                }
+            }
+            if (result.output) {
+                divider();
+                info("Output:");
+                console.log(result.output);
+            }
+            if (result.error) {
+                divider();
+                error(`Error: ${result.error}`);
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Run all test cases
+    tests
+        .command("run-all")
+        .description("Run all test cases for a prompt")
+        .argument("<prompt-id>", "Prompt ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--config <config-id>", "Override config ID for all tests")
+        .option("--json", "Output as JSON")
+        .action(async (promptId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            if (!options.json) {
+                info("Running all test cases...");
+            }
+            const result = await client.runAllTestCases(resolvedAppId, "prompt", promptId, {
+                overrideConfigId: options.config,
+            });
+            if (options.json) {
+                json(result);
+                return;
+            }
+            const { summary, results, comparisonGroup } = result;
+            divider();
+            keyValue("Comparison Group", comparisonGroup);
+            keyValue("Total Tests", summary.total);
+            keyValue("Passed", chalk.green(summary.passed));
+            keyValue("Failed", summary.failed > 0 ? chalk.red(summary.failed) : "0");
+            divider();
+            if (results && results.length > 0) {
+                for (const r of results) {
+                    const passed = r.verification?.passed;
+                    const icon = passed ? chalk.green("✓") : chalk.red("✗");
+                    const status = passed ? "PASSED" : "FAILED";
+                    console.log(`${icon} ${r.testCaseName} - ${status}`);
+                    if (!passed && r.verification?.details?.reason) {
+                        console.log(`  ${chalk.dim(r.verification.details.reason)}`);
+                    }
+                }
+            }
+            // Exit with error code if any tests failed
+            if (summary.failed > 0) {
+                process.exit(1);
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // List test runs
+    tests
+        .command("runs")
+        .description("List recent test runs for a prompt")
+        .argument("<prompt-id>", "Prompt ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--limit <n>", "Maximum number of runs to show", "20")
+        .option("--group <group>", "Filter by comparison group")
+        .option("--json", "Output as JSON")
+        .action(async (promptId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const { items } = await client.listTestRuns(resolvedAppId, "prompt", promptId, {
+                limit: parseInt(options.limit),
+                comparisonGroup: options.group,
+            });
+            if (options.json) {
+                json(items);
+                return;
+            }
+            if (!items || items.length === 0) {
+                info("No test runs found.");
+                return;
+            }
+            console.log(formatTable(items, [
+                { header: "RUN ID", key: "runId", format: formatId },
+                { header: "TEST CASE ID", key: "testCaseId", format: (v) => v ? formatId(v) : "-" },
+                {
+                    header: "PASSED",
+                    key: "verificationPassed",
+                    format: (v) => v === true
+                        ? chalk.green("Yes")
+                        : v === false
+                            ? chalk.red("No")
+                            : "-",
+                },
+                { header: "DURATION", key: "durationMs", format: formatDuration },
+                { header: "STARTED", key: "startedAt", format: formatDate },
+            ]));
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+}
+//# sourceMappingURL=prompts.js.map