@griffin-app/griffin-cli 1.0.2 → 1.0.4

package/dist/commands/hub/status.js

@@ -1,4 +1,5 @@
 import { loadState } from "../../core/state.js";
+import { terminal } from "../../utils/terminal.js";
 /**
  * Show hub connection status
  */
@@ -6,24 +7,24 @@ export async function executeStatus() {
     try {
         const state = await loadState();
         if (!state.runner) {
-            console.log("No hub connection configured.");
-            console.log("");
-            console.log("Connect with:");
-            console.log("  griffin hub connect --url <url> --token <token>");
+            terminal.warn("No hub connection configured.");
+            terminal.blank();
+            terminal.dim("Connect with:");
+            terminal.dim("  griffin hub connect --url <url> --token <token>");
             return;
         }
-        console.log("Hub connection:");
-        console.log(`  URL: ${state.runner.baseUrl}`);
+        terminal.info("Hub connection:");
+        terminal.log(`  URL: ${terminal.colors.cyan(state.runner.baseUrl)}`);
         if (state.runner.apiToken) {
-            console.log(`  API Token: ${state.runner.apiToken.substring(0, 8)}...`);
+            terminal.log(`  API Token: ${terminal.colors.dim(state.runner.apiToken.substring(0, 8) + "...")}`);
         }
         else {
-            console.log("  API Token: (not set)");
+            terminal.log(`  API Token: ${terminal.colors.dim("(not set)")}`);
         }
-        console.log("");
+        terminal.blank();
     }
     catch (error) {
-        console.error(`Error: ${error.message}`);
-        process.exit(1);
+        terminal.error(error.message);
+        terminal.exit(1);
     }
 }

package/dist/commands/init.js

@@ -1,41 +1,49 @@
 import { initState, stateExists, getStateFilePath, addEnvironment, } from "../core/state.js";
 import { detectProjectId } from "../core/project.js";
+import { terminal } from "../utils/terminal.js";
 /**
  * Initialize griffin in the current directory
  */
 export async function executeInit(options) {
-    console.log("Initializing griffin...");
+    const spinner = terminal.spinner("Initializing griffin...").start();
     // Check if already initialized
     if (await stateExists()) {
-        console.error(`Error: Already initialized (state file exists: ${getStateFilePath()})`);
-        process.exit(1);
+        spinner.fail("Already initialized");
+        terminal.dim(`State file exists: ${getStateFilePath()}`);
+        terminal.exit(1);
     }
     // Determine project ID
     let projectId = options.project;
     if (!projectId) {
         projectId = await detectProjectId();
     }
-    console.log(`Project: ${projectId}`);
-    console.log("");
+    spinner.succeed(`Project: ${terminal.colors.cyan(projectId)}`);
     // Initialize state file
     await initState(projectId);
-    console.log(`✓ Created state file: ${getStateFilePath()}`);
-    // Create a default local environment
-    await addEnvironment("local", {});
-    console.log(`✓ Created default 'local' environment`);
-    console.log("");
-    console.log("Initialization complete!");
-    console.log("");
-    console.log("Next steps:");
-    console.log("  1. Create a variables.yaml file in the project root:");
-    console.log("     environments:");
-    console.log("       local:");
-    console.log("         api-service: http://localhost:3000");
-    console.log("  2. Create test plans (*.griffin.ts files in __griffin__/ directories)");
-    console.log("  3. Run tests locally:");
-    console.log("     griffin local run");
-    console.log("  4. Connect to hub (optional):");
-    console.log("     griffin hub connect --url <url> --token <token>");
-    console.log("  5. Deploy to hub:");
-    console.log("     griffin hub apply");
+    terminal.success(`Created state file: ${terminal.colors.dim(getStateFilePath())}`);
+    // Create default environments
+    await addEnvironment("dev", {});
+    await addEnvironment("staging", {});
+    await addEnvironment("production", {});
+    terminal.success("Created default environments (dev, staging, production)");
+    terminal.blank();
+    terminal.success("Initialization complete!");
+    terminal.blank();
+    terminal.info("Next steps:");
+    terminal.dim("  1. Create a variables.yaml file in the project root:");
+    terminal.dim("     environments:");
+    terminal.dim("       dev:");
+    terminal.dim("         api-service: http://localhost:3000");
+    terminal.dim("       staging:");
+    terminal.dim("         api-service: https://staging.api.com");
+    terminal.dim("       production:");
+    terminal.dim("         api-service: https://api.example.com");
+    terminal.dim("  2. Create test plans (*.griffin.ts files in __griffin__/ directories)");
+    terminal.dim("  3. Run tests locally:");
+    terminal.dim("     griffin local run");
+    terminal.dim("  4. Connect to hub (optional):");
+    terminal.dim("     griffin hub connect --url <url> --token <token>");
+    terminal.dim("  5. Deploy to hub:");
+    terminal.dim("     griffin hub apply");
+    terminal.blank();
 }

package/dist/commands/local/run.js

@@ -1,40 +1,54 @@
 import { findTestFiles } from "../../test-discovery.js";
 import { runTestFile } from "../../test-runner.js";
 import { resolveEnvironment } from "../../core/state.js";
+import { terminal } from "../../utils/terminal.js";
 import { basename } from "path";
 export async function executeRunLocal(options = {}) {
     try {
         // Resolve environment
         const envName = await resolveEnvironment(options.env);
-        console.log(`Running tests locally against '${envName}' environment`);
-        console.log(`Variables will be loaded from variables.yaml for environment: ${envName}`);
-        console.log("");
+        terminal.info(`Running tests locally against ${terminal.colors.cyan(envName)} environment`);
+        terminal.dim(`Variables will be loaded from variables.yaml for environment: ${envName}`);
+        terminal.blank();
+        const spinner = terminal.spinner("Discovering test files...").start();
         const testFiles = findTestFiles();
         if (testFiles.length === 0) {
-            console.error("No test files found. Looking for .ts files in __griffin__ directories.");
-            process.exit(1);
+            spinner.fail("No test files found");
+            terminal.dim("Looking for .ts files in __griffin__ directories.");
+            terminal.exit(1);
         }
-        console.log(`Found ${testFiles.length} test file(s):`);
-        testFiles.forEach((file) => console.log(`  - ${file}`));
-        console.log("");
+        spinner.succeed(`Found ${terminal.colors.bold(testFiles.length.toString())} test file(s)`);
+        testFiles.forEach((file) => terminal.dim(`  - ${file}`));
+        terminal.blank();
         const results = await Promise.all(testFiles.map(async (file) => {
             const fileName = basename(file);
-            console.log(`Running ${fileName}`);
+            const testSpinner = terminal
+                .spinner(`Running ${terminal.colors.cyan(fileName)}`)
+                .start();
             const result = await runTest(file, envName);
+            if (result.success) {
+                testSpinner.succeed(`${terminal.colors.cyan(fileName)} passed`);
+            }
+            else {
+                testSpinner.fail(`${terminal.colors.cyan(fileName)} failed`);
+            }
             return result;
         }));
         // Print summary
         const successful = results.filter((r) => r.success).length;
         const failed = results.length - successful;
-        console.log("");
-        console.log(`Summary: ${successful} passed, ${failed} failed`);
-        if (failed > 0) {
-            process.exit(1);
+        terminal.blank();
+        if (failed === 0) {
+            terminal.success(`All tests passed (${terminal.colors.bold(successful.toString())} / ${results.length})`);
+        }
+        else {
+            terminal.error(`${terminal.colors.bold(failed.toString())} test(s) failed, ${terminal.colors.bold(successful.toString())} passed`);
+            terminal.exit(1);
         }
     }
     catch (error) {
-        console.error(`Error: ${error.message}`);
-        process.exit(1);
+        terminal.error(error.message);
+        terminal.exit(1);
     }
 }
 async function runTest(file, envName) {
@@ -43,7 +57,7 @@ async function runTest(file, envName) {
         return { success: result.success };
     }
     catch (error) {
-        console.error(error.message || String(error));
+        terminal.error(error.message || String(error));
         return { success: false };
     }
 }

package/dist/commands/validate.js

@@ -1,11 +1,11 @@
 import { loadState } from "../core/state.js";
 import { discoverPlans, formatDiscoveryErrors } from "../core/discovery.js";
+import { terminal } from "../utils/terminal.js";
 /**
  * Validate test plan files without syncing
  */
 export async function executeValidate() {
-    console.log("Validating test plans...");
-    console.log("");
+    const spinner = terminal.spinner("Validating test plans...").start();
     try {
         // Load state for discovery settings
         const state = await loadState();
@@ -18,29 +18,30 @@ export async function executeValidate() {
         const { plans, errors } = await discoverPlans(discoveryPattern, discoveryIgnore);
         // Report errors
         if (errors.length > 0) {
-            console.error(formatDiscoveryErrors(errors));
-            console.error("");
-            console.error(`✗ Validation failed with ${errors.length} error(s)`);
-            process.exit(1);
+            spinner.fail(`Validation failed with ${errors.length} error(s)`);
+            terminal.blank();
+            terminal.error(formatDiscoveryErrors(errors));
+            terminal.exit(1);
         }
         // Report success
-        console.log(`✓ Found ${plans.length} valid plan(s):`);
-        console.log("");
+        spinner.succeed(`Found ${terminal.colors.bold(plans.length.toString())} valid plan(s)`);
+        terminal.blank();
         for (const { plan, filePath, exportName } of plans) {
             const shortPath = filePath.replace(process.cwd(), ".");
-            const exportInfo = exportName === "default" ? "" : ` (${exportName})`;
-            console.log(`  • ${plan.name}${exportInfo}`);
-            console.log(`    ${shortPath}`);
-            console.log(`    Nodes: ${plan.nodes.length}, Edges: ${plan.edges.length}`);
+            const exportInfo = exportName === "default" ? "" : terminal.colors.dim(` (${exportName})`);
+            terminal.log(`  ${terminal.colors.green("●")} ${terminal.colors.cyan(plan.name)}${exportInfo}`);
+            terminal.dim(`    ${shortPath}`);
+            terminal.dim(`    Nodes: ${plan.nodes.length}, Edges: ${plan.edges.length}`);
             if (plan.frequency) {
-                console.log(`    Schedule: Every ${plan.frequency.every} ${plan.frequency.unit}`);
+                terminal.dim(`    Schedule: Every ${plan.frequency.every} ${plan.frequency.unit}`);
             }
-            console.log("");
+            terminal.blank();
         }
-        console.log("✓ All plans are valid");
+        terminal.success("All plans are valid");
     }
     catch (error) {
-        console.error(`Error: ${error.message}`);
-        process.exit(1);
+        spinner.fail("Validation failed");
+        terminal.error(error.message);
+        terminal.exit(1);
     }
 }

package/dist/core/apply.d.ts

@@ -1,5 +1,5 @@
 import type { DiffAction, DiffResult } from "./diff.js";
-import type { PlanApi } from "@griffin-app/griffin-hub-sdk";
+import type { GriffinHubSdk } from "@griffin-app/griffin-hub-sdk";
 export interface ApplyResult {
     success: boolean;
     applied: ApplyAction[];
@@ -19,7 +19,7 @@ export interface ApplyError {
  * Apply diff actions to the hub.
  * CLI injects both project and environment into plan payloads.
  */
-export declare function applyDiff(diff: DiffResult, planApi: PlanApi, projectId: string, environment: string, options?: {
+export declare function applyDiff(diff: DiffResult, sdk: GriffinHubSdk, projectId: string, environment: string, options?: {
     dryRun?: boolean;
 }): Promise<ApplyResult>;
 /**

package/dist/core/apply.js

@@ -1,38 +1,39 @@
+import { loadVariables } from "./variables.js";
+import { resolvePlan } from "../resolve.js";
+import { terminal } from "../utils/terminal.js";
 /**
  * Apply diff actions to the hub.
  * CLI injects both project and environment into plan payloads.
  */
-export async function applyDiff(diff, planApi, projectId, environment, options) {
+export async function applyDiff(diff, sdk, projectId, environment, options) {
     const applied = [];
     const errors = [];
     // Filter out noop actions
     const actionsToApply = diff.actions.filter((a) => a.type !== "noop");
     if (actionsToApply.length === 0) {
-        console.log("No changes to apply.");
         return { success: true, applied: [], errors: [] };
     }
-    console.log(`Applying ${actionsToApply.length} change(s)...`);
     // Process each action
     for (const action of actionsToApply) {
         try {
             if (options?.dryRun) {
-                console.log(`[DRY RUN] Would ${action.type} plan: ${action.plan?.name || action.remotePlan?.name}`);
+                terminal.dim(`[DRY RUN] Would ${action.type} plan: ${action.plan?.name || action.remotePlan?.name}`);
                 continue;
             }
             switch (action.type) {
                 case "create":
-                    await applyCreate(action, planApi, projectId, environment, applied);
+                    await applyCreate(action, sdk, projectId, environment, applied);
                     break;
                 case "update":
-                    await applyUpdate(action, planApi, projectId, environment, applied);
+                    await applyUpdate(action, sdk, projectId, environment, applied);
                     break;
                 case "delete":
-                    await applyDelete(action, planApi, applied);
+                    await applyDelete(action, sdk, applied);
                     break;
             }
         }
         catch (error) {
-            console.error(error);
+            terminal.error(error.message);
             errors.push({
                 action,
                 error: error,
@@ -54,60 +55,58 @@ export async function applyDiff(diff, planApi, projectId, environment, options)
 /**
  * Apply a create action
  */
-async function applyCreate(action, planApi, projectId, environment, applied) {
+async function applyCreate(action, sdk, projectId, environment, applied) {
     const plan = action.plan;
-    console.log(`Creating plan: ${plan.name}`);
-    // Inject project AND environment (plan itself is env-agnostic)
-    // POST body is Omit<TestPlanV1, 'id'> - hub assigns the id
-    const payload = {
-        ...plan,
-        project: projectId,
-        environment,
-    };
-    const { data: createdPlan } = await planApi.planPost(payload);
+    const variables = await loadVariables(environment);
+    const resolvedPlan = resolvePlan(plan, projectId, environment, variables);
+    const { data: createdPlan } = await sdk.postPlan({
+        body: resolvedPlan,
+    });
     applied.push({
         type: "create",
         planName: createdPlan.data.name,
         success: true,
     });
-    console.log(`✓ Created: ${createdPlan.data.name}`);
+    terminal.success(`Created: ${terminal.colors.cyan(createdPlan.data.name)}`);
 }
 /**
  * Apply an update action
  */
-async function applyUpdate(action, planApi, projectId, environment, applied) {
+async function applyUpdate(action, sdk, projectId, environment, applied) {
     const plan = action.plan;
     const remotePlan = action.remotePlan;
-    console.log(`Updating plan: ${plan.name}`);
-    // Inject project AND environment
-    // PUT body is Omit<TestPlanV1, 'id'> - id comes from URL path
-    const payload = {
-        ...plan,
-        project: projectId,
-        environment,
-    };
+    const variables = await loadVariables(environment);
+    const resolvedPlan = resolvePlan(plan, projectId, environment, variables);
     // Use the remote plan's ID for the update
-    await planApi.planIdPut(remotePlan.id, payload);
+    await sdk.putPlanById({
+        path: {
+            id: remotePlan.id,
+        },
+        body: resolvedPlan,
+    });
     applied.push({
         type: "update",
         planName: plan.name,
         success: true,
     });
-    console.log(`✓ Updated: ${plan.name}`);
+    terminal.success(`Updated: ${terminal.colors.cyan(plan.name)}`);
 }
 /**
  * Apply a delete action
  */
-async function applyDelete(action, planApi, applied) {
+async function applyDelete(action, sdk, applied) {
     const remotePlan = action.remotePlan;
-    console.log(`Deleting plan: ${remotePlan.name}`);
-    await planApi.planIdDelete(remotePlan.id);
+    await sdk.deletePlanById({
+        path: {
+            id: remotePlan.id,
+        },
+    });
     applied.push({
         type: "delete",
         planName: remotePlan.name,
         success: true,
     });
-    console.log(`✓ Deleted: ${remotePlan.name}`);
+    terminal.success(`Deleted: ${terminal.colors.cyan(remotePlan.name)}`);
 }
 /**
  * Format apply result for display

package/dist/core/apply.test.js

@@ -28,7 +28,14 @@ describe("applyDiff", () => {
     it("should skip noop actions", async () => {
         const plan = createPlan("health-check");
         const diff = {
-            actions: [{ type: "noop", plan, remotePlan: plan, reason: "unchanged" }],
+            actions: [
+                {
+                    type: "noop",
+                    plan: plan,
+                    remotePlan: plan,
+                    reason: "unchanged",
+                },
+            ],
             summary: { creates: 0, updates: 0, deletes: 0, noops: 1 },
         };
         const mockPlanApi = {};
@@ -39,7 +46,14 @@ describe("applyDiff", () => {
     it("should apply create action", async () => {
         const plan = createPlan("new-plan");
         const diff = {
-            actions: [{ type: "create", plan, remotePlan: null, reason: "new" }],
+            actions: [
+                {
+                    type: "create",
+                    plan: plan,
+                    remotePlan: null,
+                    reason: "new",
+                },
+            ],
             summary: { creates: 1, updates: 0, deletes: 0, noops: 0 },
         };
         const mockPlanApi = {
@@ -54,7 +68,7 @@ describe("applyDiff", () => {
         expect(result.applied[0].planName).toBe("new-plan");
         expect(result.applied[0].success).toBe(true);
         // Verify the API was called with injected project and environment
-        expect(mockPlanApi.planPost).toHaveBeenCalledWith(expect.objectContaining({
+        expect(mockPlanApi.postPlan).toHaveBeenCalledWith(expect.objectContaining({
             name: "new-plan",
             project: "project-id",
             environment: "staging",
@@ -65,12 +79,17 @@ describe("applyDiff", () => {
         const remotePlan = { ...localPlan, id: "remote-id" };
         const diff = {
             actions: [
-                { type: "update", plan: localPlan, remotePlan, reason: "changed" },
+                {
+                    type: "update",
+                    plan: localPlan,
+                    remotePlan: remotePlan,
+                    reason: "changed",
+                },
             ],
             summary: { creates: 0, updates: 1, deletes: 0, noops: 0 },
         };
         const mockPlanApi = {
-            planIdPut: vi.fn().mockResolvedValue({
+            putPlanById: vi.fn().mockResolvedValue({
                 data: { data: remotePlan },
             }),
         };
@@ -81,7 +100,7 @@ describe("applyDiff", () => {
         expect(result.applied[0].planName).toBe("existing-plan");
         expect(result.applied[0].success).toBe(true);
         // Verify the API was called with the remote plan's ID
-        expect(mockPlanApi.planIdPut).toHaveBeenCalledWith("remote-id", expect.objectContaining({
+        expect(mockPlanApi.putPlanById).toHaveBeenCalledWith("remote-id", expect.objectContaining({
             name: "existing-plan",
             project: "project-id",
             environment: "production",
@@ -94,7 +113,7 @@ describe("applyDiff", () => {
             summary: { creates: 0, updates: 0, deletes: 1, noops: 0 },
         };
         const mockPlanApi = {
-            planIdDelete: vi.fn().mockResolvedValue({}),
+            deletePlanById: vi.fn().mockResolvedValue({}),
         };
         const result = await applyDiff(diff, mockPlanApi, "project-id", "test");
         expect(result.success).toBe(true);
@@ -103,16 +122,23 @@ describe("applyDiff", () => {
         expect(result.applied[0].planName).toBe("old-plan");
         expect(result.applied[0].success).toBe(true);
         // Verify the API was called with the remote plan's ID
-        expect(mockPlanApi.planIdDelete).toHaveBeenCalledWith(remotePlan.id);
+        expect(mockPlanApi.deletePlanById).toHaveBeenCalledWith(remotePlan.id);
     });
     it("should handle errors gracefully", async () => {
         const plan = createPlan("failing-plan");
         const diff = {
-            actions: [{ type: "create", plan, remotePlan: null, reason: "new" }],
+            actions: [
+                {
+                    type: "create",
+                    plan: plan,
+                    remotePlan: null,
+                    reason: "new",
+                },
+            ],
             summary: { creates: 1, updates: 0, deletes: 0, noops: 0 },
         };
         const mockPlanApi = {
-            planPost: vi.fn().mockRejectedValue(new Error("API Error")),
+            postPlan: vi.fn().mockRejectedValue(new Error("API Error")),
         };
         const result = await applyDiff(diff, mockPlanApi, "project-id", "test");
         expect(result.success).toBe(false);
@@ -124,7 +150,14 @@ describe("applyDiff", () => {
     it("should skip actions in dry-run mode", async () => {
         const plan = createPlan("dry-run-plan");
         const diff = {
-            actions: [{ type: "create", plan, remotePlan: null, reason: "new" }],
+            actions: [
+                {
+                    type: "create",
+                    plan: plan,
+                    remotePlan: null,
+                    reason: "new",
+                },
+            ],
             summary: { creates: 1, updates: 0, deletes: 0, noops: 0 },
         };
         const mockPlanApi = {
@@ -135,6 +168,6 @@ describe("applyDiff", () => {
         });
         expect(result.success).toBe(true);
         expect(result.applied).toHaveLength(0);
-        expect(mockPlanApi.planPost).not.toHaveBeenCalled();
+        expect(mockPlanApi.postPlan).not.toHaveBeenCalled();
     });
 });

package/dist/core/diff.d.ts

@@ -1,11 +1,11 @@
-import type { TestPlanV1 } from "@griffin-app/griffin-ts/types";
-import { RawTestPlan } from "./discovery.js";
+import type { PlanV1 } from "@griffin-app/griffin-hub-sdk";
+import type { PlanDSL } from "@griffin-app/griffin-ts/types";
 import { type PlanChanges } from "./plan-diff.js";
 export type DiffActionType = "create" | "update" | "delete" | "noop";
 export interface DiffAction {
     type: DiffActionType;
-    plan: RawTestPlan | null;
-    remotePlan: TestPlanV1 | null;
+    plan: PlanDSL | null;
+    remotePlan: PlanV1 | null;
     reason: string;
     changes?: PlanChanges;
 }
@@ -31,7 +31,7 @@ export interface DiffOptions {
  * - DELETE: Plan exists on hub but not locally (only if includeDeletions is true)
  * - NOOP: Plan exists in both with same content
  */
-export declare function computeDiff(localPlans: RawTestPlan[], remotePlans: TestPlanV1[], options: DiffOptions): DiffResult;
+export declare function computeDiff(localPlans: PlanDSL[], remotePlans: PlanV1[], options: DiffOptions): DiffResult;
 /**
  * Format diff result as human-readable text with granular changes
  */

package/dist/core/diff.test.js

@@ -1,6 +1,5 @@
 import { describe, it, expect } from "vitest";
 import { computeDiff } from "./diff.js";
-import { FrequencyUnit } from "@griffin-app/griffin-ts/schema";
 // Helper to create a minimal test plan
 function createPlan(name, overrides) {
     return {
@@ -9,7 +8,7 @@ function createPlan(name, overrides) {
         project: "test-project",
         environment: "test",
         version: "1.0",
-        frequency: { every: 5, unit: FrequencyUnit.MINUTE },
+        frequency: { every: 5, unit: "MINUTE" },
         nodes: [],
         edges: [],
         ...overrides,
@@ -20,7 +19,9 @@ describe("computeDiff", () => {
         it("should create action when plan exists locally but not remotely", () => {
             const local = [createPlan("health-check")];
             const remote = [];
-            const result = computeDiff(local, remote, { includeDeletions: false });
+            const result = computeDiff(local, remote, {
+                includeDeletions: false,
+            });
             expect(result.actions).toHaveLength(1);
             expect(result.actions[0].type).toBe("create");
             expect(result.actions[0].plan?.name).toBe("health-check");
@@ -34,15 +35,17 @@ describe("computeDiff", () => {
         it("should create update action when plan content differs", () => {
             const local = [
                 createPlan("health-check", {
-                    frequency: { every: 10, unit: FrequencyUnit.MINUTE },
+                    frequency: { every: 10, unit: "MINUTE" },
                 }),
             ];
             const remote = [
                 createPlan("health-check", {
-                    frequency: { every: 5, unit: FrequencyUnit.MINUTE },
+                    frequency: { every: 5, unit: "MINUTE" },
                 }),
             ];
-            const result = computeDiff(local, remote, { includeDeletions: false });
+            const result = computeDiff(local, remote, {
+                includeDeletions: false,
+            });
             expect(result.actions).toHaveLength(1);
             expect(result.actions[0].type).toBe("update");
             expect(result.actions[0].plan?.name).toBe("health-check");
@@ -57,7 +60,9 @@ describe("computeDiff", () => {
             const plan = createPlan("health-check");
             const local = [plan];
             const remote = [{ ...plan }];
-            const result = computeDiff(local, remote, { includeDeletions: false });
+            const result = computeDiff(local, remote, {
+                includeDeletions: false,
+            });
             expect(result.actions).toHaveLength(1);
             expect(result.actions[0].type).toBe("noop");
             expect(result.summary.creates).toBe(0);
@@ -90,18 +95,20 @@ describe("computeDiff", () => {
             const local = [
                 createPlan("new-plan"),
                 createPlan("updated-plan", {
-                    frequency: { every: 10, unit: FrequencyUnit.MINUTE },
+                    frequency: { every: 10, unit: "MINUTE" },
                 }),
                 createPlan("unchanged-plan"),
             ];
             const remote = [
                 createPlan("updated-plan", {
-                    frequency: { every: 5, unit: FrequencyUnit.MINUTE },
+                    frequency: { every: 5, unit: "MINUTE" },
                 }),
                 createPlan("unchanged-plan"),
                 createPlan("deleted-plan"),
             ];
-            const result = computeDiff(local, remote, { includeDeletions: true });
+            const result = computeDiff(local, remote, {
+                includeDeletions: true,
+            });
             expect(result.actions).toHaveLength(4);
             expect(result.summary.creates).toBe(1);
             expect(result.summary.updates).toBe(1);
@@ -113,7 +120,9 @@ describe("computeDiff", () => {
         it("should match plans by name, not by ID", () => {
             const local = [createPlan("health-check", { id: "local-id-123" })];
             const remote = [createPlan("health-check", { id: "remote-id-456" })];
-            const result = computeDiff(local, remote, { includeDeletions: false });
+            const result = computeDiff(local, remote, {
+                includeDeletions: false,
+            });
             // Should be NOOP because names match (IDs are ignored)
             expect(result.actions).toHaveLength(1);
             expect(result.actions[0].type).toBe("noop");