@griffin-app/griffin-cli 1.0.6 → 1.0.7

package/dist/core/apply.test.js

@@ -1,9 +1,9 @@
 import { describe, it, expect, vi } from "vitest";
 import { applyDiff } from "./apply.js";
-// Helper to create a minimal test plan
-function createPlan(name) {
+// Helper to create a minimal test monitor
+function createMonitor(name) {
     return {
-        id: `plan-${name}`,
+        id: `monitor-${name}`,
         name,
         project: "test-project",
         environment: "test",
@@ -19,92 +19,92 @@ describe("applyDiff", () => {
             actions: [],
             summary: { creates: 0, updates: 0, deletes: 0, noops: 0 },
         };
-        const mockPlanApi = {};
-        const result = await applyDiff(diff, mockPlanApi);
+        const mockMonitorApi = {};
+        const result = await applyDiff(diff, mockMonitorApi);
         expect(result.success).toBe(true);
         expect(result.applied).toHaveLength(0);
         expect(result.errors).toHaveLength(0);
     });
     it("should skip noop actions", async () => {
-        const plan = createPlan("health-check");
+        const monitor = createMonitor("health-check");
         const diff = {
             actions: [
                 {
                     type: "noop",
-                    plan: plan,
-                    remotePlan: plan,
+                    monitor: monitor,
+                    remoteMonitor: monitor,
                     reason: "unchanged",
                 },
             ],
             summary: { creates: 0, updates: 0, deletes: 0, noops: 1 },
         };
-        const mockPlanApi = {};
-        const result = await applyDiff(diff, mockPlanApi);
+        const mockMonitorApi = {};
+        const result = await applyDiff(diff, mockMonitorApi);
         expect(result.success).toBe(true);
         expect(result.applied).toHaveLength(0);
     });
     it("should apply create action", async () => {
-        const plan = createPlan("new-plan");
+        const monitor = createMonitor("new-monitor");
         const diff = {
             actions: [
                 {
                     type: "create",
-                    plan: plan,
-                    remotePlan: null,
+                    monitor: monitor,
+                    remoteMonitor: null,
                     reason: "new",
                 },
             ],
             summary: { creates: 1, updates: 0, deletes: 0, noops: 0 },
         };
-        const mockPlanApi = {
-            postPlan: vi.fn().mockResolvedValue({
-                data: { data: { ...plan, id: "created-id" } },
+        const mockMonitorApi = {
+            postMonitor: vi.fn().mockResolvedValue({
+                data: { data: { ...monitor, id: "created-id" } },
             }),
         };
-        const result = await applyDiff(diff, mockPlanApi);
+        const result = await applyDiff(diff, mockMonitorApi);
         expect(result.success).toBe(true);
         expect(result.applied).toHaveLength(1);
         expect(result.applied[0].type).toBe("create");
-        expect(result.applied[0].planName).toBe("new-plan");
+        expect(result.applied[0].monitorName).toBe("new-monitor");
         expect(result.applied[0].success).toBe(true);
         // Verify the API was called with injected project and environment
-        expect(mockPlanApi.postPlan).toHaveBeenCalledWith(expect.objectContaining({
+        expect(mockMonitorApi.postMonitor).toHaveBeenCalledWith(expect.objectContaining({
             body: expect.objectContaining({
-                name: "new-plan",
+                name: "new-monitor",
                 project: "test-project",
                 environment: "test",
             }),
         }));
     });
     it("should apply update action", async () => {
-        const localPlan = createPlan("existing-plan");
-        const remotePlan = { ...localPlan, id: "remote-id" };
+        const localMonitor = createMonitor("existing-monitor");
+        const remoteMonitor = { ...localMonitor, id: "remote-id" };
         const diff = {
             actions: [
                 {
                     type: "update",
-                    plan: localPlan,
-                    remotePlan: remotePlan,
+                    monitor: localMonitor,
+                    remoteMonitor: remoteMonitor,
                     reason: "changed",
                 },
             ],
             summary: { creates: 0, updates: 1, deletes: 0, noops: 0 },
         };
-        const mockPlanApi = {
-            putPlanById: vi.fn().mockResolvedValue({
-                data: { data: remotePlan },
+        const mockMonitorApi = {
+            putMonitorById: vi.fn().mockResolvedValue({
+                data: { data: remoteMonitor },
             }),
         };
-        const result = await applyDiff(diff, mockPlanApi);
+        const result = await applyDiff(diff, mockMonitorApi);
         expect(result.success).toBe(true);
         expect(result.applied).toHaveLength(1);
         expect(result.applied[0].type).toBe("update");
-        expect(result.applied[0].planName).toBe("existing-plan");
+        expect(result.applied[0].monitorName).toBe("existing-monitor");
         expect(result.applied[0].success).toBe(true);
-        // Verify the API was called with the remote plan's ID
-        expect(mockPlanApi.putPlanById).toHaveBeenCalledWith(expect.objectContaining({
+        // Verify the API was called with the remote monitor's ID
+        expect(mockMonitorApi.putMonitorById).toHaveBeenCalledWith(expect.objectContaining({
             body: expect.objectContaining({
-                name: "existing-plan",
+                name: "existing-monitor",
                 project: "test-project",
                 environment: "test",
             }),
@@ -114,44 +114,44 @@ describe("applyDiff", () => {
         }));
     });
     it("should apply delete action", async () => {
-        const remotePlan = createPlan("old-plan");
+        const remoteMonitor = createMonitor("old-monitor");
         const diff = {
-            actions: [{ type: "delete", plan: null, remotePlan, reason: "removed" }],
+            actions: [{ type: "delete", monitor: null, remoteMonitor, reason: "removed" }],
             summary: { creates: 0, updates: 0, deletes: 1, noops: 0 },
         };
-        const mockPlanApi = {
-            deletePlanById: vi.fn().mockResolvedValue({}),
+        const mockMonitorApi = {
+            deleteMonitorById: vi.fn().mockResolvedValue({}),
         };
-        const result = await applyDiff(diff, mockPlanApi);
+        const result = await applyDiff(diff, mockMonitorApi);
         expect(result.success).toBe(true);
         expect(result.applied).toHaveLength(1);
         expect(result.applied[0].type).toBe("delete");
-        expect(result.applied[0].planName).toBe("old-plan");
+        expect(result.applied[0].monitorName).toBe("old-monitor");
         expect(result.applied[0].success).toBe(true);
-        // Verify the API was called with the remote plan's ID
-        expect(mockPlanApi.deletePlanById).toHaveBeenCalledWith({
+        // Verify the API was called with the remote monitor's ID
+        expect(mockMonitorApi.deleteMonitorById).toHaveBeenCalledWith({
             path: {
-                id: remotePlan.id,
+                id: remoteMonitor.id,
             },
         });
     });
     it("should handle errors gracefully", async () => {
-        const plan = createPlan("failing-plan");
+        const monitor = createMonitor("failing-monitor");
         const diff = {
             actions: [
                 {
                     type: "create",
-                    plan: plan,
-                    remotePlan: null,
+                    monitor: monitor,
+                    remoteMonitor: null,
                     reason: "new",
                 },
             ],
             summary: { creates: 1, updates: 0, deletes: 0, noops: 0 },
         };
-        const mockPlanApi = {
-            postPlan: vi.fn().mockRejectedValue(new Error("API Error")),
+        const mockMonitorApi = {
+            postMonitor: vi.fn().mockRejectedValue(new Error("API Error")),
         };
-        const result = await applyDiff(diff, mockPlanApi);
+        const result = await applyDiff(diff, mockMonitorApi);
         expect(result.success).toBe(false);
         expect(result.errors).toHaveLength(1);
         expect(result.applied).toHaveLength(1);
@@ -159,26 +159,26 @@ describe("applyDiff", () => {
         expect(result.applied[0].error).toBe("API Error");
     });
     it("should skip actions in dry-run mode", async () => {
-        const plan = createPlan("dry-run-plan");
+        const monitor = createMonitor("dry-run-monitor");
         const diff = {
             actions: [
                 {
                     type: "create",
-                    plan: plan,
-                    remotePlan: null,
+                    monitor: monitor,
+                    remoteMonitor: null,
                     reason: "new",
                 },
             ],
             summary: { creates: 1, updates: 0, deletes: 0, noops: 0 },
         };
-        const mockPlanApi = {
-            postPlan: vi.fn(),
+        const mockMonitorApi = {
+            postMonitor: vi.fn(),
         };
-        const result = await applyDiff(diff, mockPlanApi, {
+        const result = await applyDiff(diff, mockMonitorApi, {
             dryRun: true,
         });
         expect(result.success).toBe(true);
         expect(result.applied).toHaveLength(0);
-        expect(mockPlanApi.postPlan).not.toHaveBeenCalled();
+        expect(mockMonitorApi.postMonitor).not.toHaveBeenCalled();
     });
 });

package/dist/core/diff.d.ts

@@ -1,13 +1,13 @@
-import type { PlanV1 } from "@griffin-app/griffin-hub-sdk";
-import { type PlanChanges } from "./plan-diff.js";
+import type { MonitorV1 } from "@griffin-app/griffin-hub-sdk";
+import { type MonitorChanges } from "./monitor-diff.js";
 export type DiffActionType = "create" | "update" | "delete" | "noop";
-export type ResolvedPlan = Omit<PlanV1, "id">;
+export type ResolvedMonitor = Omit<MonitorV1, "id">;
 export interface DiffAction {
     type: DiffActionType;
-    plan: ResolvedPlan | null;
-    remotePlan: PlanV1 | null;
+    monitor: ResolvedMonitor | null;
+    remoteMonitor: MonitorV1 | null;
     reason: string;
-    changes?: PlanChanges;
+    changes?: MonitorChanges;
 }
 export interface DiffResult {
     actions: DiffAction[];
@@ -22,17 +22,17 @@ export interface DiffOptions {
     includeDeletions: boolean;
 }
 /**
- * Compute diff between local plans and remote plans (hub is source of truth).
- * Local plans should be resolved (variables replaced with actual values) before calling this.
- * Plans are matched by name.
+ * Compute diff between local monitors and remote monitors (hub is source of truth).
+ * Local monitors should be resolved (variables replaced with actual values) before calling this.
+ * Monitors are matched by name.
  *
  * Rules:
- * - CREATE: Plan exists locally but not on hub
- * - UPDATE: Plan exists in both, but content differs
- * - DELETE: Plan exists on hub but not locally (only if includeDeletions is true)
- * - NOOP: Plan exists in both with same content
+ * - CREATE: Monitor exists locally but not on hub
+ * - UPDATE: Monitor exists in both, but content differs
+ * - DELETE: Monitor exists on hub but not locally (only if includeDeletions is true)
+ * - NOOP: Monitor exists in both with same content
  */
-export declare function computeDiff(localPlans: ResolvedPlan[], remotePlans: PlanV1[], options: DiffOptions): DiffResult;
+export declare function computeDiff(localMonitors: ResolvedMonitor[], remoteMonitors: MonitorV1[], options: DiffOptions): DiffResult;
 /**
  * Format diff result as human-readable text with granular changes
  */

package/dist/core/diff.js

@@ -1,71 +1,71 @@
-import { comparePlans } from "./plan-diff.js";
+import { compareMonitors } from "./monitor-diff.js";
 /**
- * Compute diff between local plans and remote plans (hub is source of truth).
- * Local plans should be resolved (variables replaced with actual values) before calling this.
- * Plans are matched by name.
+ * Compute diff between local monitors and remote monitors (hub is source of truth).
+ * Local monitors should be resolved (variables replaced with actual values) before calling this.
+ * Monitors are matched by name.
  *
  * Rules:
- * - CREATE: Plan exists locally but not on hub
- * - UPDATE: Plan exists in both, but content differs
- * - DELETE: Plan exists on hub but not locally (only if includeDeletions is true)
- * - NOOP: Plan exists in both with same content
+ * - CREATE: Monitor exists locally but not on hub
+ * - UPDATE: Monitor exists in both, but content differs
+ * - DELETE: Monitor exists on hub but not locally (only if includeDeletions is true)
+ * - NOOP: Monitor exists in both with same content
  */
-export function computeDiff(localPlans, remotePlans, options) {
+export function computeDiff(localMonitors, remoteMonitors, options) {
     const actions = [];
-    // Build lookup: remote plans by name
+    // Build lookup: remote monitors by name
     const remoteByName = new Map();
-    for (const plan of remotePlans) {
-        remoteByName.set(plan.name, plan);
+    for (const monitor of remoteMonitors) {
+        remoteByName.set(monitor.name, monitor);
     }
     const localNames = new Set();
-    for (const plan of localPlans) {
-        localNames.add(plan.name);
+    for (const monitor of localMonitors) {
+        localNames.add(monitor.name);
     }
-    // Check local plans against remote
-    for (const local of localPlans) {
+    // Check local monitors against remote
+    for (const local of localMonitors) {
         const remote = remoteByName.get(local.name);
         if (!remote) {
-            // Plan not on hub -> CREATE
+            // Monitor not on hub -> CREATE
             actions.push({
                 type: "create",
-                plan: local,
-                remotePlan: null,
-                reason: `Plan "${local.name}" does not exist on hub`,
+                monitor: local,
+                remoteMonitor: null,
+                reason: `Monitor "${local.name}" does not exist on hub`,
             });
         }
         else {
-            // Plan exists in both - compute granular changes
-            const changes = comparePlans(local, remote);
+            // Monitor exists in both - compute granular changes
+            const changes = compareMonitors(local, remote);
             if (changes.hasChanges) {
-                // Plan on hub but differs -> UPDATE
+                // Monitor on hub but differs -> UPDATE
                 actions.push({
                     type: "update",
-                    plan: local,
-                    remotePlan: remote,
-                    reason: `Plan "${local.name}" has local changes`,
+                    monitor: local,
+                    remoteMonitor: remote,
+                    reason: `Monitor "${local.name}" has local changes`,
                     changes,
                 });
             }
             else {
-                // Plan matches -> NOOP
+                // Monitor matches -> NOOP
                 actions.push({
                     type: "noop",
-                    plan: local,
-                    remotePlan: remote,
-                    reason: `Plan "${local.name}" is up to date`,
+                    monitor: local,
+                    remoteMonitor: remote,
+                    reason: `Monitor "${local.name}" is up to date`,
                 });
             }
         }
     }
-    // Check for plans on hub not present locally -> DELETE (only if --prune)
+    // Check for monitors on hub not present locally -> DELETE (only if --prune)
     if (options.includeDeletions) {
-        for (const remote of remotePlans) {
+        for (const remote of remoteMonitors) {
             if (!localNames.has(remote.name)) {
                 actions.push({
                     type: "delete",
-                    plan: null,
-                    remotePlan: remote,
-                    reason: `Plan "${remote.name}" no longer exists locally`,
+                    monitor: null,
+                    remoteMonitor: remote,
+                    reason: `Monitor "${remote.name}" no longer exists locally`,
                 });
             }
         }
@@ -90,21 +90,21 @@ export function formatDiff(diff) {
         lines.push("No changes. Infrastructure is up to date.");
         return lines.join("\n");
     }
-    lines.push("Plan:");
+    lines.push("Monitor:");
     lines.push("");
     for (const action of diff.actions) {
         if (action.type === "create") {
-            lines.push(`  + ${action.plan.name} (create)`);
+            lines.push(`  + ${action.monitor.name} (create)`);
         }
         else if (action.type === "update") {
-            lines.push(`  ~ ${action.plan.name} (update)`);
+            lines.push(`  ~ ${action.monitor.name} (update)`);
             // Show granular changes for updates
             if (action.changes) {
-                formatPlanChanges(action.changes, lines);
+                formatMonitorChanges(action.changes, lines);
             }
         }
         else if (action.type === "delete") {
-            lines.push(`  - ${action.remotePlan.name} (delete)`);
+            lines.push(`  - ${action.remoteMonitor.name} (delete)`);
         }
     }
     lines.push("");
@@ -115,9 +115,9 @@ export function formatDiff(diff) {
     return lines.join("\n");
 }
 /**
- * Format granular plan changes in terraform style
+ * Format granular monitor changes in terraform style
  */
-function formatPlanChanges(changes, lines) {
+function formatMonitorChanges(changes, lines) {
     // Nodes section
     if (changes.nodes.length > 0) {
         lines.push("      Nodes:");

package/dist/core/diff.test.js

@@ -1,9 +1,9 @@
 import { describe, it, expect } from "vitest";
 import { computeDiff } from "./diff.js";
-// Helper to create a minimal test plan
-function createPlan(name, overrides) {
+// Helper to create a minimal test monitor
+function createMonitor(name, overrides) {
     return {
-        id: `plan-${name}`,
+        id: `monitor-${name}`,
         name,
         project: "test-project",
         environment: "test",
@@ -14,8 +14,8 @@ function createPlan(name, overrides) {
         ...overrides,
     };
 }
-// Helper to create a resolved plan (without id)
-function createResolvedPlan(name, overrides) {
+// Helper to create a resolved monitor (without id)
+function createResolvedMonitor(name, overrides) {
     return {
         name,
         project: "test-project",
@@ -29,30 +29,30 @@ function createResolvedPlan(name, overrides) {
 }
 describe("computeDiff", () => {
     describe("CREATE actions", () => {
-        it("should create action when plan exists locally but not remotely", () => {
-            const local = [createResolvedPlan("health-check")];
+        it("should create action when monitor exists locally but not remotely", () => {
+            const local = [createResolvedMonitor("health-check")];
             const remote = [];
             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");
-            expect(result.actions[0].remotePlan).toBeNull();
+            expect(result.actions[0].monitor?.name).toBe("health-check");
+            expect(result.actions[0].remoteMonitor).toBeNull();
             expect(result.summary.creates).toBe(1);
             expect(result.summary.updates).toBe(0);
             expect(result.summary.deletes).toBe(0);
         });
     });
     describe("UPDATE actions", () => {
-        it("should create update action when plan content differs", () => {
+        it("should create update action when monitor content differs", () => {
             const local = [
-                createResolvedPlan("health-check", {
+                createResolvedMonitor("health-check", {
                     frequency: { every: 10, unit: "MINUTE" },
                 }),
             ];
             const remote = [
-                createPlan("health-check", {
+                createMonitor("health-check", {
                     frequency: { every: 5, unit: "MINUTE" },
                 }),
             ];
@@ -61,19 +61,19 @@ describe("computeDiff", () => {
             });
             expect(result.actions).toHaveLength(1);
             expect(result.actions[0].type).toBe("update");
-            expect(result.actions[0].plan?.name).toBe("health-check");
-            expect(result.actions[0].remotePlan?.name).toBe("health-check");
+            expect(result.actions[0].monitor?.name).toBe("health-check");
+            expect(result.actions[0].remoteMonitor?.name).toBe("health-check");
             expect(result.summary.creates).toBe(0);
             expect(result.summary.updates).toBe(1);
             expect(result.summary.deletes).toBe(0);
         });
     });
     describe("NOOP actions", () => {
-        it("should create noop action when plan content matches", () => {
-            const resolvedPlan = createResolvedPlan("health-check");
-            const remotePlan = createPlan("health-check");
-            const local = [resolvedPlan];
-            const remote = [remotePlan];
+        it("should create noop action when monitor content matches", () => {
+            const resolvedMonitor = createResolvedMonitor("health-check");
+            const remoteMonitor = createMonitor("health-check");
+            const local = [resolvedMonitor];
+            const remote = [remoteMonitor];
             const result = computeDiff(local, remote, {
                 includeDeletions: false,
             });
@@ -88,37 +88,37 @@ describe("computeDiff", () => {
     describe("DELETE actions", () => {
         it("should not create delete action when includeDeletions is false", () => {
             const local = [];
-            const remote = [createPlan("old-plan")];
+            const remote = [createMonitor("old-monitor")];
             const result = computeDiff(local, remote, { includeDeletions: false });
             expect(result.actions).toHaveLength(0);
             expect(result.summary.deletes).toBe(0);
         });
         it("should create delete action when includeDeletions is true", () => {
             const local = [];
-            const remote = [createPlan("old-plan")];
+            const remote = [createMonitor("old-monitor")];
             const result = computeDiff(local, remote, { includeDeletions: true });
             expect(result.actions).toHaveLength(1);
             expect(result.actions[0].type).toBe("delete");
-            expect(result.actions[0].plan).toBeNull();
-            expect(result.actions[0].remotePlan?.name).toBe("old-plan");
+            expect(result.actions[0].monitor).toBeNull();
+            expect(result.actions[0].remoteMonitor?.name).toBe("old-monitor");
             expect(result.summary.deletes).toBe(1);
         });
     });
     describe("Mixed scenarios", () => {
-        it("should handle multiple plans with different actions", () => {
+        it("should handle multiple monitors with different actions", () => {
             const local = [
-                createResolvedPlan("new-plan"),
-                createResolvedPlan("updated-plan", {
+                createResolvedMonitor("new-monitor"),
+                createResolvedMonitor("updated-monitor", {
                     frequency: { every: 10, unit: "MINUTE" },
                 }),
-                createResolvedPlan("unchanged-plan"),
+                createResolvedMonitor("unchanged-monitor"),
             ];
             const remote = [
-                createPlan("updated-plan", {
+                createMonitor("updated-monitor", {
                     frequency: { every: 5, unit: "MINUTE" },
                 }),
-                createPlan("unchanged-plan"),
-                createPlan("deleted-plan"),
+                createMonitor("unchanged-monitor"),
+                createMonitor("deleted-monitor"),
             ];
             const result = computeDiff(local, remote, {
                 includeDeletions: true,
@@ -131,10 +131,10 @@ describe("computeDiff", () => {
         });
     });
     describe("Matching by name", () => {
-        it("should match plans by name, not by ID", () => {
-            // Local plans don't have IDs after resolution
-            const local = [createResolvedPlan("health-check")];
-            const remote = [createPlan("health-check", { id: "remote-id-456" })];
+        it("should match monitors by name, not by ID", () => {
+            // Local monitors don't have IDs after resolution
+            const local = [createResolvedMonitor("health-check")];
+            const remote = [createMonitor("health-check", { id: "remote-id-456" })];
             const result = computeDiff(local, remote, {
                 includeDeletions: false,
             });

package/dist/core/discovery.d.ts

@@ -1,11 +1,11 @@
-import type { PlanDSL } from "@griffin-app/griffin-ts/types";
-export interface DiscoveredPlan {
-    plan: PlanDSL;
+import type { MonitorDSL } from "@griffin-app/griffin-ts/types";
+export interface DiscoveredMonitor {
+    monitor: MonitorDSL;
     filePath: string;
     exportName: string;
 }
 export interface DiscoveryResult {
-    plans: DiscoveredPlan[];
+    monitors: DiscoveredMonitor[];
     errors: DiscoveryError[];
 }
 export interface DiscoveryError {
@@ -13,9 +13,9 @@ export interface DiscoveryError {
     error: Error;
 }
 /**
- * Discover and load test plan files from the filesystem
+ * Discover and load test monitor files from the filesystem
  */
-export declare function discoverPlans(pattern: string, ignore: string[]): Promise<DiscoveryResult>;
+export declare function discoverMonitors(pattern: string, ignore: string[]): Promise<DiscoveryResult>;
 /**
  * Format discovery errors for display
  */