primitive-admin 1.0.6 → 1.0.8

package/dist/src/commands/sync.js

@@ -1,6 +1,7 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, unlinkSync, rmdirSync, statSync } from "fs";
 import { join, basename } from "path";
 import * as TOML from "@iarna/toml";
+import { lookup as mimeLookup } from "mime-types";
 import { ApiClient, ConflictError } from "../lib/api-client.js";
 import { getCurrentAppId, getServerUrl } from "../lib/config.js";
 import { success, error, info, warn, keyValue, json, divider, } from "../lib/output.js";
@@ -99,19 +100,38 @@ function serializePrompt(prompt) {
     };
     return TOML.stringify(data);
 }
-function serializeWorkflow(workflow, draft) {
+function serializeWorkflow(workflow, draft, configs) {
+    // Find the active config or use the first one
+    const activeConfigId = workflow.activeConfigId;
+    const activeConfig = configs?.find((c) => c.configId === activeConfigId) || configs?.[0];
+    // Determine which steps to use (prefer config steps if non-empty, else draft steps)
+    const configSteps = activeConfig?.steps;
+    const draftSteps = draft?.steps;
+    const steps = (configSteps && configSteps.length > 0) ? configSteps : (draftSteps || []);
     const data = {
         workflow: {
             key: workflow.workflowKey,
             name: workflow.name,
             description: workflow.description,
             status: workflow.status,
+            activeConfigId: activeConfigId,
             perUserMaxRunning: workflow.perUserMaxRunning,
             perUserMaxQueued: workflow.perUserMaxQueued,
             dequeueOrder: workflow.dequeueOrder,
-            inputSchema: draft?.inputSchema ? JSON.stringify(draft.inputSchema) : undefined,
+            // Schemas are at workflow level
+            inputSchema: workflow.inputSchema ? JSON.stringify(workflow.inputSchema) : undefined,
+            outputSchema: workflow.outputSchema ? JSON.stringify(workflow.outputSchema) : undefined,
         },
-        steps: draft?.steps || [],
+        // Use active config steps, fall back to draft
+        steps,
+        // Include all configurations
+        configs: configs?.map((config) => ({
+            id: config.configId,
+            name: config.configName,
+            description: config.description,
+            status: config.status,
+            isActive: config.configId === activeConfigId,
+        })) || [],
     };
     return TOML.stringify(data);
 }
@@ -120,6 +140,320 @@ function parseTomlFile(filePath) {
     const content = readFileSync(filePath, "utf-8");
     return TOML.parse(content);
 }
+// Test case helpers (exported for unit testing)
+export function slugifyTestCaseName(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        || "test";
+}
+export function resolveSlugCollisions(slug, usedSlugs) {
+    if (!usedSlugs.has(slug)) {
+        usedSlugs.add(slug);
+        return slug;
+    }
+    let counter = 2;
+    while (usedSlugs.has(`${slug}-${counter}`)) {
+        counter++;
+    }
+    const resolved = `${slug}-${counter}`;
+    usedSlugs.add(resolved);
+    return resolved;
+}
+function getTestsDir(configDir, blockType, blockKey) {
+    const typeDir = blockType === "prompt" ? "prompts" : "workflows";
+    return join(configDir, typeDir, `${blockKey}.tests`);
+}
+export function serializeTestCase(testCase) {
+    const data = {
+        test: {
+            name: testCase.name || "",
+            description: testCase.description || "",
+            inputVariables: testCase.inputVariables || "{}",
+            configId: testCase.configId || "",
+            evaluatorPromptId: testCase.evaluatorPromptId || "",
+            evaluatorConfigId: testCase.evaluatorConfigId || "",
+            expectedOutputPattern: testCase.expectedOutputPattern || "",
+            expectedOutputContains: testCase.expectedOutputContains || "[]",
+            expectedJsonSubset: testCase.expectedJsonSubset || "{}",
+        },
+    };
+    return TOML.stringify(data);
+}
+export function parseTestCaseToml(tomlData) {
+    const test = tomlData.test || {};
+    const payload = {
+        name: test.name,
+    };
+    if (test.inputVariables && test.inputVariables !== "{}" && test.inputVariables !== "") {
+        try {
+            payload.inputVariables = JSON.parse(test.inputVariables);
+        }
+        catch {
+            payload.inputVariables = {};
+        }
+    }
+    else {
+        payload.inputVariables = {};
+    }
+    if (test.description && test.description !== "") {
+        payload.description = test.description;
+    }
+    if (test.configId && test.configId !== "") {
+        payload.configId = test.configId;
+    }
+    if (test.evaluatorPromptId && test.evaluatorPromptId !== "") {
+        payload.evaluatorPromptId = test.evaluatorPromptId;
+    }
+    if (test.evaluatorConfigId && test.evaluatorConfigId !== "") {
+        payload.evaluatorConfigId = test.evaluatorConfigId;
+    }
+    if (test.expectedOutputPattern && test.expectedOutputPattern !== "") {
+        payload.expectedOutputPattern = test.expectedOutputPattern;
+    }
+    if (test.expectedOutputContains && test.expectedOutputContains !== "[]" && test.expectedOutputContains !== "") {
+        try {
+            payload.expectedOutputContains = JSON.parse(test.expectedOutputContains);
+        }
+        catch {
+            // ignore
+        }
+    }
+    if (test.expectedJsonSubset && test.expectedJsonSubset !== "{}" && test.expectedJsonSubset !== "") {
+        try {
+            payload.expectedJsonSubset = JSON.parse(test.expectedJsonSubset);
+        }
+        catch {
+            // ignore
+        }
+    }
+    return payload;
+}
+async function pullTestCasesForBlock(client, appId, blockType, blockId, blockKey, configDir, testCaseEntities) {
+    let testCases;
+    try {
+        const result = await client.listTestCases(appId, blockType, blockId);
+        testCases = result.items || [];
+    }
+    catch {
+        return 0;
+    }
+    if (testCases.length === 0)
+        return 0;
+    const testsDir = getTestsDir(configDir, blockType, blockKey);
+    ensureDir(testsDir);
+    const usedSlugs = new Set();
+    const pulledSlugs = new Set();
+    for (const tc of testCases) {
+        const baseSlug = slugifyTestCaseName(tc.name || "unnamed");
+        const slug = resolveSlugCollisions(baseSlug, usedSlugs);
+        pulledSlugs.add(slug);
+        // Write test case TOML
+        const tomlPath = join(testsDir, `${slug}.toml`);
+        writeFileSync(tomlPath, serializeTestCase(tc));
+        // Handle attachments
+        let attachmentFilenames = [];
+        try {
+            const attachResult = await client.listTestCaseAttachments(appId, blockType, blockId, tc.testCaseId);
+            const attachments = attachResult.attachments || [];
+            if (attachments.length > 0) {
+                const attachDir = join(testsDir, slug);
+                ensureDir(attachDir);
+                for (const att of attachments) {
+                    try {
+                        const downloaded = await client.downloadTestCaseAttachment(appId, blockType, blockId, tc.testCaseId, att.filename);
+                        writeFileSync(join(attachDir, att.filename), downloaded.data);
+                        attachmentFilenames.push(att.filename);
+                    }
+                    catch (err) {
+                        // Log but skip individual attachment failures
+                        console.error(`  Warning: Failed to download attachment "${att.filename}": ${err.message || err}`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            // Log but skip attachment listing failures
+            console.error(`  Warning: Failed to list attachments for test case "${tc.name}": ${err.message || err}`);
+        }
+        // Track in sync state
+        const stateKey = `${blockType}/${blockKey}/${slug}`;
+        testCaseEntities[stateKey] = {
+            id: tc.testCaseId,
+            blockType,
+            blockId,
+            blockKey,
+            slug,
+            modifiedAt: tc.modifiedAt || tc.createdAt || new Date().toISOString(),
+            attachmentFilenames: attachmentFilenames.length > 0 ? attachmentFilenames : undefined,
+        };
+    }
+    // Clean up local files for remotely-deleted test cases
+    if (existsSync(testsDir)) {
+        const localFiles = readdirSync(testsDir).filter((f) => f.endsWith(".toml"));
+        for (const file of localFiles) {
+            const localSlug = basename(file, ".toml");
+            if (!pulledSlugs.has(localSlug)) {
+                // Remove orphaned TOML
+                unlinkSync(join(testsDir, file));
+                // Remove orphaned attachment dir if exists
+                const attachDir = join(testsDir, localSlug);
+                if (existsSync(attachDir)) {
+                    try {
+                        const attachFiles = readdirSync(attachDir);
+                        for (const af of attachFiles) {
+                            unlinkSync(join(attachDir, af));
+                        }
+                        rmdirSync(attachDir);
+                    }
+                    catch {
+                        // ignore cleanup errors
+                    }
+                }
+            }
+        }
+    }
+    return testCases.length;
+}
+async function pushTestCasesForBlock(client, appId, blockType, blockId, blockKey, configDir, syncState, dryRun, changes) {
+    const testsDir = getTestsDir(configDir, blockType, blockKey);
+    if (!existsSync(testsDir))
+        return;
+    const files = readdirSync(testsDir).filter((f) => f.endsWith(".toml"));
+    if (files.length === 0)
+        return;
+    const TEN_MB = 10 * 1024 * 1024;
+    for (const file of files) {
+        const slug = basename(file, ".toml");
+        const filePath = join(testsDir, file);
+        const tomlData = parseTomlFile(filePath);
+        const testPayload = parseTestCaseToml(tomlData);
+        const stateKey = `${blockType}/${blockKey}/${slug}`;
+        const existingEntry = syncState?.entities?.testCases?.[stateKey];
+        if (existingEntry?.id) {
+            // Update existing test case
+            changes.push({ type: "test-case", action: "update", key: `${blockKey}/${slug}` });
+            if (!dryRun) {
+                try {
+                    await client.updateTestCase(appId, blockType, blockId, existingEntry.id, testPayload);
+                    info(`  Updated test case: ${blockKey}/${slug}`);
+                }
+                catch (err) {
+                    warn(`  Failed to update test case ${blockKey}/${slug}: ${err.message}`);
+                    continue;
+                }
+            }
+        }
+        else {
+            // Create new test case
+            if (!testPayload.name) {
+                warn(`  Skipping test case ${blockKey}/${slug}: missing name`);
+                continue;
+            }
+            changes.push({ type: "test-case", action: "create", key: `${blockKey}/${slug}` });
+            if (!dryRun) {
+                try {
+                    const created = await client.createTestCase(appId, blockType, blockId, testPayload);
+                    info(`  Created test case: ${blockKey}/${slug}`);
+                    // Record in sync state
+                    if (syncState) {
+                        if (!syncState.entities.testCases) {
+                            syncState.entities.testCases = {};
+                        }
+                        syncState.entities.testCases[stateKey] = {
+                            id: created.testCaseId,
+                            blockType,
+                            blockId,
+                            blockKey,
+                            slug,
+                            modifiedAt: created.modifiedAt || created.createdAt || new Date().toISOString(),
+                        };
+                    }
+                }
+                catch (err) {
+                    warn(`  Failed to create test case ${blockKey}/${slug}: ${err.message}`);
+                    continue;
+                }
+            }
+        }
+        // Handle attachments (only on actual push, not dry run)
+        if (!dryRun) {
+            const testCaseId = existingEntry?.id || syncState?.entities?.testCases?.[stateKey]?.id;
+            if (!testCaseId)
+                continue;
+            const attachDir = join(testsDir, slug);
+            if (!existsSync(attachDir))
+                continue;
+            const localAttachFiles = readdirSync(attachDir).filter((f) => {
+                const fullPath = join(attachDir, f);
+                try {
+                    return statSync(fullPath).isFile();
+                }
+                catch {
+                    return false;
+                }
+            });
+            const prevAttachments = new Set(existingEntry?.attachmentFilenames || []);
+            for (const attachFile of localAttachFiles) {
+                if (prevAttachments.has(attachFile)) {
+                    // Already synced, skip
+                    continue;
+                }
+                const attachPath = join(attachDir, attachFile);
+                const stats = statSync(attachPath);
+                if (stats.size > TEN_MB) {
+                    warn(`  Skipping attachment ${attachFile} (exceeds 10MB limit): ${formatFileSize(stats.size)}`);
+                    continue;
+                }
+                try {
+                    const data = readFileSync(attachPath);
+                    const contentType = mimeLookup(attachPath) || "application/octet-stream";
+                    await client.uploadTestCaseAttachment(appId, blockType, blockId, testCaseId, attachFile, data, contentType);
+                    changes.push({ type: "attachment", action: "upload", key: `${blockKey}/${slug}/${attachFile}` });
+                    info(`  Uploaded attachment: ${blockKey}/${slug}/${attachFile}`);
+                    // Update sync state attachment tracking
+                    if (syncState?.entities?.testCases?.[stateKey]) {
+                        const entry = syncState.entities.testCases[stateKey];
+                        if (!entry.attachmentFilenames)
+                            entry.attachmentFilenames = [];
+                        entry.attachmentFilenames.push(attachFile);
+                    }
+                }
+                catch (err) {
+                    warn(`  Failed to upload attachment ${attachFile}: ${err.message}`);
+                }
+            }
+            // Delete attachments that were removed locally
+            for (const prevFile of prevAttachments) {
+                if (!localAttachFiles.includes(prevFile)) {
+                    try {
+                        await client.deleteTestCaseAttachment(appId, blockType, blockId, testCaseId, prevFile);
+                        changes.push({ type: "attachment", action: "delete", key: `${blockKey}/${slug}/${prevFile}` });
+                        info(`  Deleted attachment: ${blockKey}/${slug}/${prevFile}`);
+                        // Update sync state
+                        if (syncState?.entities?.testCases?.[stateKey]) {
+                            const entry = syncState.entities.testCases[stateKey];
+                            if (entry.attachmentFilenames) {
+                                entry.attachmentFilenames = entry.attachmentFilenames.filter((f) => f !== prevFile);
+                            }
+                        }
+                    }
+                    catch (err) {
+                        warn(`  Failed to delete attachment ${prevFile}: ${err.message}`);
+                    }
+                }
+            }
+        }
+    }
+}
+function formatFileSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
 export function registerSyncCommands(program) {
     const sync = program
         .command("sync")
@@ -133,11 +467,13 @@ Examples:
 
 Directory Structure:
   config/
-    .primitive-sync.json      # Sync state (auto-managed)
-    app.toml            # App settings
-    integrations/*.toml # Integration configs
-    prompts/*.toml      # Prompt configs
-    workflows/*.toml    # Workflow definitions
+    .primitive-sync.json        # Sync state (auto-managed)
+    app.toml                    # App settings
+    integrations/*.toml         # Integration configs
+    prompts/*.toml              # Prompt configs
+    prompts/{key}.tests/*.toml  # Prompt test cases
+    workflows/*.toml            # Workflow definitions
+    workflows/{key}.tests/*.toml # Workflow test cases
 `);
     // Init
     sync
@@ -187,7 +523,27 @@ Directory Structure:
             // Fetch details for each entity
             const integrations = await Promise.all(integrationsResult.items.map((i) => client.getIntegration(resolvedAppId, i.integrationId)));
             const prompts = await Promise.all(promptsResult.items.map((p) => client.getPrompt(resolvedAppId, p.promptId)));
-            const workflows = await Promise.all(workflowsResult.items.map((w) => client.getWorkflow(resolvedAppId, w.workflowId)));
+            const workflows = await Promise.all(workflowsResult.items.map(async (w) => {
+                const workflowData = await client.getWorkflow(resolvedAppId, w.workflowId);
+                // Fetch active config with steps if available
+                const activeConfigId = workflowData.workflow?.activeConfigId;
+                if (activeConfigId) {
+                    try {
+                        const activeConfig = await client.getWorkflowConfig(resolvedAppId, w.workflowId, activeConfigId);
+                        // Replace the config in the configs array with the one that has steps
+                        if (workflowData.configs && activeConfig) {
+                            const configIndex = workflowData.configs.findIndex((c) => c.configId === activeConfigId);
+                            if (configIndex >= 0) {
+                                workflowData.configs[configIndex] = activeConfig;
+                            }
+                        }
+                    }
+                    catch {
+                        // Ignore errors fetching config steps
+                    }
+                }
+                return workflowData;
+            }));
             if (options.json) {
                 json({ settings, integrations, prompts, workflows });
                 return;
@@ -226,15 +582,33 @@ Directory Structure:
             }
             // Write workflows
             const workflowEntities = {};
-            for (const { workflow, draft } of workflows) {
+            for (const { workflow, draft, configs } of workflows) {
                 const filename = `${workflow.workflowKey}.toml`;
-                writeFileSync(join(configDir, "workflows", filename), serializeWorkflow(workflow, draft));
+                writeFileSync(join(configDir, "workflows", filename), serializeWorkflow(workflow, draft, configs || []));
                 workflowEntities[workflow.workflowKey] = {
                     id: workflow.workflowId,
                     modifiedAt: workflow.modifiedAt || new Date().toISOString(),
+                    activeConfigId: workflow.activeConfigId,
                 };
                 info(`  Wrote workflows/${filename}`);
             }
+            // Pull test cases for prompts and workflows
+            const testCaseEntities = {};
+            let totalTestCases = 0;
+            for (const prompt of prompts) {
+                const count = await pullTestCasesForBlock(client, resolvedAppId, "prompt", prompt.promptId, prompt.promptKey, configDir, testCaseEntities);
+                if (count > 0) {
+                    info(`  Wrote ${count} test case(s) for prompt: ${prompt.promptKey}`);
+                }
+                totalTestCases += count;
+            }
+            for (const { workflow } of workflows) {
+                const count = await pullTestCasesForBlock(client, resolvedAppId, "workflow", workflow.workflowId, workflow.workflowKey, configDir, testCaseEntities);
+                if (count > 0) {
+                    info(`  Wrote ${count} test case(s) for workflow: ${workflow.workflowKey}`);
+                }
+                totalTestCases += count;
+            }
             // Save sync state
             const state = {
                 appId: resolvedAppId,
@@ -245,6 +619,7 @@ Directory Structure:
                     integrations: integrationEntities,
                     prompts: promptEntities,
                     workflows: workflowEntities,
+                    testCases: Object.keys(testCaseEntities).length > 0 ? testCaseEntities : undefined,
                 },
             };
             saveSyncState(configDir, state);
@@ -253,6 +628,7 @@ Directory Structure:
             keyValue("Integrations", integrations.length);
             keyValue("Prompts", prompts.length);
             keyValue("Workflows", workflows.length);
+            keyValue("Test Cases", totalTestCases);
         }
         catch (err) {
             error(err.message);
@@ -466,6 +842,7 @@ Directory Structure:
                     const key = workflow.key || basename(file, ".toml");
                     const steps = tomlData.steps || [];
                     const existingId = syncState?.entities?.workflows?.[key]?.id;
+                    const existingActiveConfigId = syncState?.entities?.workflows?.[key]?.activeConfigId;
                     if (existingId) {
                         // Update existing workflow
                         changes.push({ type: "workflow", action: "update", key });
@@ -474,6 +851,7 @@ Directory Structure:
                                 ? undefined
                                 : syncState?.entities?.workflows?.[key]?.modifiedAt;
                             try {
+                                // Update workflow metadata and schemas
                                 const updated = await client.updateWorkflow(resolvedAppId, existingId, {
                                     name: workflow.name,
                                     description: workflow.description,
@@ -481,12 +859,22 @@ Directory Structure:
                                     perUserMaxRunning: workflow.perUserMaxRunning,
                                     perUserMaxQueued: workflow.perUserMaxQueued,
                                     dequeueOrder: workflow.dequeueOrder,
-                                }, expectedModifiedAt);
-                                // Update draft (no conflict detection - always overwrite)
-                                await client.updateWorkflowDraft(resolvedAppId, existingId, {
-                                    steps,
                                     inputSchema: workflow.inputSchema ? JSON.parse(workflow.inputSchema) : null,
-                                });
+                                    outputSchema: workflow.outputSchema ? JSON.parse(workflow.outputSchema) : null,
+                                }, expectedModifiedAt);
+                                // Update active configuration steps (or draft for legacy)
+                                if (existingActiveConfigId) {
+                                    await client.updateWorkflowConfig(resolvedAppId, existingId, existingActiveConfigId, {
+                                        steps,
+                                    });
+                                }
+                                else {
+                                    // Fallback to draft update for legacy workflows
+                                    await client.updateWorkflowDraft(resolvedAppId, existingId, {
+                                        steps,
+                                        inputSchema: workflow.inputSchema ? JSON.parse(workflow.inputSchema) : null,
+                                    });
+                                }
                                 info(`  Updated workflow: ${key}`);
                                 // Update sync state with new modifiedAt
                                 if (syncState?.entities?.workflows?.[key] && updated?.workflow?.modifiedAt) {
@@ -509,7 +897,7 @@ Directory Structure:
                         }
                     }
                     else {
-                        // Create new workflow
+                        // Create new workflow (automatically creates default config)
                         changes.push({ type: "workflow", action: "create", key });
                         if (!options.dryRun) {
                             const created = await client.createWorkflow(resolvedAppId, {
@@ -518,12 +906,13 @@ Directory Structure:
                                 description: workflow.description,
                                 steps,
                                 inputSchema: workflow.inputSchema ? JSON.parse(workflow.inputSchema) : undefined,
+                                outputSchema: workflow.outputSchema ? JSON.parse(workflow.outputSchema) : undefined,
                                 perUserMaxRunning: workflow.perUserMaxRunning,
                                 perUserMaxQueued: workflow.perUserMaxQueued,
                                 dequeueOrder: workflow.dequeueOrder,
                             });
                             info(`  Created workflow: ${key}`);
-                            // Add new entity to sync state
+                            // Add new entity to sync state (including activeConfigId)
                             if (syncState && created?.workflow?.workflowId && created?.workflow?.modifiedAt) {
                                 if (!syncState.entities.workflows) {
                                     syncState.entities.workflows = {};
@@ -531,18 +920,44 @@ Directory Structure:
                                 syncState.entities.workflows[key] = {
                                     id: created.workflow.workflowId,
                                     modifiedAt: created.workflow.modifiedAt,
+                                    activeConfigId: created.workflow.activeConfigId,
                                 };
                             }
                         }
                     }
                 }
             }
+            // Push test cases for prompts and workflows
+            const promptsDir2 = join(configDir, "prompts");
+            if (existsSync(promptsDir2)) {
+                for (const file of readdirSync(promptsDir2).filter((f) => f.endsWith(".toml"))) {
+                    const tomlData = parseTomlFile(join(promptsDir2, file));
+                    const promptKey = tomlData.prompt?.key || basename(file, ".toml");
+                    const blockId = syncState?.entities?.prompts?.[promptKey]?.id;
+                    if (blockId) {
+                        await pushTestCasesForBlock(client, resolvedAppId, "prompt", blockId, promptKey, configDir, syncState, options.dryRun, changes);
+                    }
+                }
+            }
+            const workflowsDir2 = join(configDir, "workflows");
+            if (existsSync(workflowsDir2)) {
+                for (const file of readdirSync(workflowsDir2).filter((f) => f.endsWith(".toml"))) {
+                    const tomlData = parseTomlFile(join(workflowsDir2, file));
+                    const workflowKey = tomlData.workflow?.key || basename(file, ".toml");
+                    const blockId = syncState?.entities?.workflows?.[workflowKey]?.id;
+                    if (blockId) {
+                        await pushTestCasesForBlock(client, resolvedAppId, "workflow", blockId, workflowKey, configDir, syncState, options.dryRun, changes);
+                    }
+                }
+            }
             divider();
             if (options.dryRun) {
                 info("Dry run - no changes applied.");
                 console.log("\nChanges that would be made:");
                 for (const change of changes) {
-                    const color = change.action === "create" ? chalk.green : chalk.yellow;
+                    const color = change.action === "create" ? chalk.green
+                        : change.action === "delete" ? chalk.red
+                            : chalk.yellow;
                     console.log(`  ${color(change.action)} ${change.type}: ${change.key}`);
                 }
             }
@@ -689,6 +1104,53 @@ Directory Structure:
                     differences.push({ type: "workflow", key, status: "remote only" });
                 }
             }
+            // Compare test cases for synced prompts and workflows
+            const testCaseDiffs = [];
+            // Helper to compare test cases for a block
+            const compareTestCases = async (blockType, blockId, blockKey) => {
+                // Get remote test cases
+                let remoteTestNames;
+                try {
+                    const result = await client.listTestCases(resolvedAppId, blockType, blockId);
+                    const items = result.items || [];
+                    remoteTestNames = new Set(items.map((tc) => slugifyTestCaseName(tc.name || "unnamed")));
+                }
+                catch {
+                    return;
+                }
+                // Get local test case files
+                const testsDir = getTestsDir(configDir, blockType, blockKey);
+                const localTestSlugs = new Set();
+                if (existsSync(testsDir)) {
+                    for (const f of readdirSync(testsDir).filter((f) => f.endsWith(".toml"))) {
+                        localTestSlugs.add(basename(f, ".toml"));
+                    }
+                }
+                for (const slug of localTestSlugs) {
+                    if (!remoteTestNames.has(slug)) {
+                        testCaseDiffs.push({ blockType, blockKey, slug, status: "local only" });
+                    }
+                    else {
+                        testCaseDiffs.push({ blockType, blockKey, slug, status: "exists" });
+                    }
+                }
+                for (const slug of remoteTestNames) {
+                    if (!localTestSlugs.has(slug)) {
+                        testCaseDiffs.push({ blockType, blockKey, slug, status: "remote only" });
+                    }
+                }
+            };
+            // Compare test cases for synced blocks
+            for (const p of promptsResult.items) {
+                if (localPrompts.has(p.promptKey)) {
+                    await compareTestCases("prompt", p.promptId, p.promptKey);
+                }
+            }
+            for (const w of workflowsResult.items) {
+                if (localWorkflows.has(w.workflowKey)) {
+                    await compareTestCases("workflow", w.workflowId, w.workflowKey);
+                }
+            }
             divider();
             const localOnly = differences.filter((d) => d.status === "local only");
             const remoteOnly = differences.filter((d) => d.status === "remote only");
@@ -713,10 +1175,32 @@ Directory Structure:
                     console.log(`  ${chalk.dim("=")} ${d.type}: ${d.key}`);
                 }
             }
+            // Show test case differences
+            const tcLocalOnly = testCaseDiffs.filter((d) => d.status === "local only");
+            const tcRemoteOnly = testCaseDiffs.filter((d) => d.status === "remote only");
+            const tcSynced = testCaseDiffs.filter((d) => d.status === "exists");
+            if (tcLocalOnly.length > 0 || tcRemoteOnly.length > 0) {
+                console.log();
+                info("Test Cases:");
+                for (const d of tcLocalOnly) {
+                    console.log(`  ${chalk.green("+")} ${d.blockType}/${d.blockKey} test-case: ${d.slug}`);
+                }
+                for (const d of tcRemoteOnly) {
+                    console.log(`  ${chalk.red("-")} ${d.blockType}/${d.blockKey} test-case: ${d.slug}`);
+                }
+                for (const d of tcSynced) {
+                    console.log(`  ${chalk.dim("=")} ${d.blockType}/${d.blockKey} test-case: ${d.slug}`);
+                }
+            }
             divider();
             keyValue("Local only", localOnly.length);
             keyValue("Remote only", remoteOnly.length);
             keyValue("Synced", existing.length);
+            if (testCaseDiffs.length > 0) {
+                keyValue("Test Cases (local only)", tcLocalOnly.length);
+                keyValue("Test Cases (remote only)", tcRemoteOnly.length);
+                keyValue("Test Cases (synced)", tcSynced.length);
+            }
         }
         catch (err) {
             error(err.message);