@griffin-app/griffin-cli 1.0.6 → 1.0.8

package/dist/commands/local/run.d.ts

@@ -1,4 +1,4 @@
 export interface RunLocalOptions {
-    env?: string;
+    env: string;
 }
-export declare function executeRunLocal(options?: RunLocalOptions): Promise<void>;
+export declare function executeRunLocal(options: RunLocalOptions): Promise<void>;

package/dist/commands/local/run.js

@@ -3,7 +3,7 @@ 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 = {}) {
+export async function executeRunLocal(options) {
     try {
         // Resolve environment
         const envName = await resolveEnvironment(options.env);

package/dist/commands/plan.d.ts

@@ -1,8 +1,8 @@
-export interface PlanOptions {
+export interface MonitorOptions {
     json?: boolean;
     env?: string;
 }
 /**
  * Show what changes would be applied
  */
-export declare function executePlan(options: PlanOptions): Promise<void>;
+export declare function executeMonitor(options: MonitorOptions): Promise<void>;

package/dist/commands/plan.js

@@ -1,11 +1,11 @@
 import { loadState, resolveEnvironment } from "../core/state.js";
-import { discoverPlans, formatDiscoveryErrors } from "../core/discovery.js";
+import { discoverMonitors, formatDiscoveryErrors } from "../core/discovery.js";
 import { createSdkClients } from "../core/sdk.js";
 import { computeDiff, formatDiff, formatDiffJson } from "../core/diff.js";
 /**
  * Show what changes would be applied
  */
-export async function executePlan(options) {
+export async function executeMonitor(options) {
     try {
         // Load state
         const state = await loadState();
@@ -17,13 +17,13 @@ export async function executePlan(options) {
             console.log("  griffin runner set --base-url <url> --api-token <token>");
             process.exit(1);
         }
-        // Discover local plans
+        // Discover local monitors
         const discoveryPattern = state.discovery?.pattern || "**/__griffin__/*.{ts,js}";
         const discoveryIgnore = state.discovery?.ignore || [
             "node_modules/**",
             "dist/**",
         ];
-        const { plans, errors } = await discoverPlans(discoveryPattern, discoveryIgnore);
+        const { monitors, errors } = await discoverMonitors(discoveryPattern, discoveryIgnore);
         if (errors.length > 0) {
             console.error(formatDiscoveryErrors(errors));
             process.exit(1);
@@ -33,11 +33,11 @@ export async function executePlan(options) {
             baseUrl: state.runner.baseUrl,
             apiToken: state.runner.apiToken || undefined,
         });
-        // Fetch remote plans for this project
+        // Fetch remote monitors for this project
         const response = await planApi.planGet(state.projectId);
-        const remotePlans = response.data.data.map((p) => p);
+        const remoteMonitors = response.data.data.map((p) => p);
         // Compute diff for this environment
-        const diff = computeDiff(plans.map((p) => p.plan), state, remotePlans, envName);
+        const diff = computeDiff(monitors.map((p) => p.monitor), state, remoteMonitors, envName);
         // Output
         if (options.json) {
             console.log(formatDiffJson(diff));

package/dist/commands/run-remote.d.ts

@@ -6,6 +6,6 @@ export interface RunOptions {
     targetEnv?: string;
 }
 /**
- * Trigger a plan run on the runner
+ * Trigger a monitor run on the runner
  */
 export declare function executeRun(options: RunOptions): Promise<void>;

package/dist/commands/run-remote.js

@@ -1,13 +1,13 @@
 import { loadState, resolveEnvironment } from "../core/state.js";
 import { createSdkClients } from "../core/sdk.js";
 /**
- * Trigger a plan run on the runner
+ * Trigger a monitor run on the runner
  */
 export async function executeRun(options) {
     try {
-        // TODO: remove this. Users shoud be able to execute all plans if they want.
+        // TODO: remove this. Users shoud be able to execute all monitors if they want.
         if (!options.planId && !options.planName) {
-            console.error("Error: Either --plan-id or --plan-name must be provided");
+            console.error("Error: Either --monitor-id or --monitor-name must be provided");
             process.exit(1);
         }
         if (!options.targetEnv) {
@@ -27,24 +27,24 @@ export async function executeRun(options) {
             baseUrl: state.runner.baseUrl,
             apiToken: state.runner.apiToken || undefined,
         });
-        // Resolve plan ID from name if needed
+        // Resolve monitor ID from name if needed
         let planId = options.planId;
         if (!planId && options.planName) {
             // Resolve environment to search in
             const envName = await resolveEnvironment(options.env);
-            const envPlans = state.plans[envName] || [];
-            const stateEntry = envPlans.find((p) => p.planName === options.planName);
+            const envMonitors = state.monitors[envName] || [];
+            const stateEntry = envMonitors.find((p) => p.planName === options.planName);
             if (!stateEntry) {
-                console.error(`Error: Plan "${options.planName}" not found in state`);
-                console.error("Run 'griffin apply' to sync your plans first");
+                console.error(`Error: Monitor "${options.planName}" not found in state`);
+                console.error("Run 'griffin apply' to sync your monitors first");
                 process.exit(1);
             }
             planId = stateEntry.planId;
         }
         // Trigger the run with environment
-        console.log(`Triggering run for plan: ${planId}`);
+        console.log(`Triggering run for monitor: ${planId}`);
         console.log(`Target environment: ${options.targetEnv}`);
-        const response = await runsApi.runsTriggerPlanIdPost(planId, {
+        const response = await runsApi.runsTriggerMonitorIdPost(planId, {
             environment: options.targetEnv,
         });
         console.log(`Run ID: ${response.data.data.id}`);

package/dist/commands/validate.d.ts

@@ -1,4 +1,4 @@
 /**
- * Validate test plan files without syncing
+ * Validate test monitor files without syncing
  */
 export declare function executeValidate(): Promise<void>;

package/dist/commands/validate.js

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

package/dist/core/apply.d.ts

@@ -7,7 +7,7 @@ export interface ApplyResult {
 }
 export interface ApplyAction {
     type: "create" | "update" | "delete";
-    planName: string;
+    monitorName: string;
     success: boolean;
     error?: string;
 }
@@ -17,7 +17,7 @@ export interface ApplyError {
 }
 /**
  * Apply diff actions to the hub.
- * CLI injects both project and environment into plan payloads.
+ * CLI injects both project and environment into monitor payloads.
  */
 export declare function applyDiff(diff: DiffResult, sdk: GriffinHubSdk, options?: {
     dryRun?: boolean;

package/dist/core/apply.js

@@ -2,7 +2,7 @@ import { terminal } from "../utils/terminal.js";
 import { withSDKErrorHandling } from "../utils/sdk-error.js";
 /**
  * Apply diff actions to the hub.
- * CLI injects both project and environment into plan payloads.
+ * CLI injects both project and environment into monitor payloads.
  */
 export async function applyDiff(diff, sdk, options) {
     const applied = [];
@@ -16,7 +16,7 @@ export async function applyDiff(diff, sdk, options) {
     for (const action of actionsToApply) {
         try {
             if (options?.dryRun) {
-                terminal.dim(`[DRY RUN] Would ${action.type} plan: ${action.plan?.name || action.remotePlan?.name}`);
+                terminal.dim(`[DRY RUN] Would ${action.type} monitor: ${action.monitor?.name || action.remoteMonitor?.name}`);
                 continue;
             }
             switch (action.type) {
@@ -39,7 +39,7 @@ export async function applyDiff(diff, sdk, options) {
             });
             applied.push({
                 type: action.type,
-                planName: action.plan?.name || action.remotePlan?.name || "unknown",
+                monitorName: action.monitor?.name || action.remoteMonitor?.name || "unknown",
                 success: false,
                 error: error.message,
             });
@@ -55,57 +55,57 @@ export async function applyDiff(diff, sdk, options) {
  * Apply a create action
  */
 async function applyCreate(action, sdk, applied) {
-    const resolvedPlan = action.plan;
+    const resolvedMonitor = action.monitor;
     //const variables = await loadVariables(environment);
-    //const resolvedPlan = resolvePlan(plan, projectId, environment, variables);
-    const { data: createdPlan } = await sdk.postPlan({
-        body: resolvedPlan,
+    //const resolvedMonitor = resolveMonitor(monitor, projectId, environment, variables);
+    const { data: createdMonitor } = await sdk.postMonitor({
+        body: resolvedMonitor,
     });
     applied.push({
         type: "create",
-        planName: createdPlan.data.name,
+        monitorName: createdMonitor.data.name,
         success: true,
     });
-    terminal.success(`Created: ${terminal.colors.cyan(createdPlan.data.name)}`);
+    terminal.success(`Created: ${terminal.colors.cyan(createdMonitor.data.name)}`);
 }
 /**
  * Apply an update action
  */
 async function applyUpdate(action, sdk, applied) {
-    const resolvedPlan = action.plan;
-    //const remotePlan = action.remotePlan!;
+    const resolvedMonitor = action.monitor;
+    //const remoteMonitor = action.remoteMonitor!;
     //const variables = await loadVariables(environment);
-    //const resolvedPlan = resolvePlan(plan, projectId, environment, variables);
-    // Use the remote plan's ID for the update
-    await sdk.putPlanById({
+    //const resolvedMonitor = resolveMonitor(monitor, projectId, environment, variables);
+    // Use the remote monitor's ID for the update
+    await sdk.putMonitorById({
         path: {
-            id: action.remotePlan.id,
+            id: action.remoteMonitor.id,
         },
-        body: resolvedPlan,
+        body: resolvedMonitor,
     });
     applied.push({
         type: "update",
-        planName: action.remotePlan.name,
+        monitorName: action.remoteMonitor.name,
         success: true,
     });
-    terminal.success(`Updated: ${terminal.colors.cyan(action.remotePlan.name)}`);
+    terminal.success(`Updated: ${terminal.colors.cyan(action.remoteMonitor.name)}`);
 }
 /**
  * Apply a delete action
  */
 async function applyDelete(action, sdk, applied) {
-    const remotePlan = action.remotePlan;
-    await withSDKErrorHandling(() => sdk.deletePlanById({
+    const remoteMonitor = action.remoteMonitor;
+    await withSDKErrorHandling(() => sdk.deleteMonitorById({
         path: {
-            id: remotePlan.id,
+            id: remoteMonitor.id,
         },
-    }), `Failed to delete plan "${remotePlan.name}"`);
+    }), `Failed to delete monitor "${remoteMonitor.name}"`);
     applied.push({
         type: "delete",
-        planName: remotePlan.name,
+        monitorName: remoteMonitor.name,
         success: true,
     });
-    terminal.success(`Deleted: ${terminal.colors.cyan(remotePlan.name)}`);
+    terminal.success(`Deleted: ${terminal.colors.cyan(remoteMonitor.name)}`);
 }
 /**
  * Format apply result for display
@@ -121,7 +121,7 @@ export function formatApplyResult(result) {
     for (const action of result.applied) {
         const icon = action.success ? "✓" : "✗";
         const status = action.success ? action.type : `${action.type} (failed)`;
-        lines.push(`  ${icon} ${action.planName} - ${status}`);
+        lines.push(`  ${icon} ${action.monitorName} - ${status}`);
         if (action.error) {
             lines.push(`    Error: ${action.error}`);
         }

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
  */