@griffin-app/griffin-cli 1.0.0 → 1.0.2

package/dist/core/discovery.d.ts

@@ -0,0 +1,23 @@
+import type { TestPlanV1 } from "@griffin-app/griffin-ts/types";
+export type RawTestPlan = Omit<TestPlanV1, "id" | "environment" | "project">;
+export interface DiscoveredPlan {
+    plan: RawTestPlan;
+    filePath: string;
+    exportName: string;
+}
+export interface DiscoveryResult {
+    plans: DiscoveredPlan[];
+    errors: DiscoveryError[];
+}
+export interface DiscoveryError {
+    filePath: string;
+    error: Error;
+}
+/**
+ * Discover and load test plan files from the filesystem
+ */
+export declare function discoverPlans(pattern: string, ignore: string[]): Promise<DiscoveryResult>;
+/**
+ * Format discovery errors for display
+ */
+export declare function formatDiscoveryErrors(errors: DiscoveryError[]): string;

package/dist/core/discovery.js

@@ -0,0 +1,89 @@
+import { glob } from "glob";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { TestPlanV1Schema } from "@griffin-app/griffin-ts/schema";
+import { Value } from "typebox/value";
+import { Type } from "typebox";
+const RawTestPlanSchema = Type.Omit(TestPlanV1Schema, [
+    "id",
+    "environment",
+    "project",
+]);
+/**
+ * Discover and load test plan files from the filesystem
+ */
+export async function discoverPlans(pattern, ignore) {
+    const plans = [];
+    const errors = [];
+    // Find all matching files
+    const files = await glob(pattern, {
+        ignore,
+        absolute: true,
+        cwd: process.cwd(),
+    });
+    console.log(`Found ${files.length} test file(s)`);
+    // Load each file
+    for (const filePath of files) {
+        try {
+            const loaded = await loadPlansFromFile(filePath);
+            plans.push(...loaded);
+        }
+        catch (error) {
+            errors.push({
+                filePath,
+                error: error,
+            });
+        }
+    }
+    return { plans, errors };
+}
+function isPlan(value) {
+    return Value.Check(RawTestPlanSchema, value);
+}
+/**
+ * Load plans from a single file
+ * Supports both default and named exports
+ */
+async function loadPlansFromFile(filePath) {
+    const plans = [];
+    // Convert to file URL for dynamic import (works with both ESM and CJS)
+    const fileUrl = pathToFileURL(filePath).href;
+    try {
+        const module = await import(fileUrl);
+        // Check default export
+        if (module.default) {
+            if (isPlan(module.default)) {
+                plans.push({
+                    plan: module.default,
+                    filePath,
+                    exportName: "default",
+                });
+            }
+            else {
+                const errors = Value.Errors(RawTestPlanSchema, module.default);
+                throw new Error(`Default export is not a valid TestPlan. Got: ${JSON.stringify(errors, null, 2)}`);
+            }
+        }
+        if (plans.length === 0) {
+            throw new Error("No valid TestPlan exports found in file");
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to load ${filePath}: ${error.message}`);
+    }
+    return plans;
+}
+/**
+ * Format discovery errors for display
+ */
+export function formatDiscoveryErrors(errors) {
+    if (errors.length === 0)
+        return "";
+    const lines = ["Errors during discovery:"];
+    for (const { filePath, error } of errors) {
+        const relativePath = path.relative(process.cwd(), filePath);
+        lines.push(`  ❌ ${relativePath}`);
+        lines.push(`     ${error.message}`);
+    }
+    return lines.join("\n");
+}

package/dist/core/plan-diff.d.ts

@@ -0,0 +1,42 @@
+import type { RawTestPlan } from "./discovery.js";
+import type { TestPlanV1 } from "@griffin-app/griffin-ts/types";
+import { NodeType } from "@griffin-app/griffin-ts/schema";
+/**
+ * Represents a change to a single field
+ */
+export interface FieldChange {
+    field: string;
+    oldValue: unknown;
+    newValue: unknown;
+}
+/**
+ * Represents a change to a node (add/remove/modify)
+ */
+export interface NodeChange {
+    type: "add" | "remove" | "modify";
+    nodeId: string;
+    nodeType: NodeType;
+    summary: string;
+    fieldChanges: FieldChange[];
+}
+/**
+ * Represents a change to an edge (add/remove)
+ */
+export interface EdgeChange {
+    type: "add" | "remove";
+    from: string;
+    to: string;
+}
+/**
+ * Complete set of changes between local and remote plans
+ */
+export interface PlanChanges {
+    hasChanges: boolean;
+    nodes: NodeChange[];
+    edges: EdgeChange[];
+    topLevel: FieldChange[];
+}
+/**
+ * Compare two test plans and return granular changes
+ */
+export declare function comparePlans(local: RawTestPlan, remote: TestPlanV1): PlanChanges;

package/dist/core/plan-diff.js

@@ -0,0 +1,257 @@
+import objectHash from "object-hash";
+/**
+ * Compare two test plans and return granular changes
+ */
+export function comparePlans(local, remote) {
+    const nodeChanges = compareNodes(local.nodes, remote.nodes);
+    const edgeChanges = compareEdges(local.edges, remote.edges);
+    const topLevelChanges = compareTopLevel(local, remote);
+    const hasChanges = nodeChanges.length > 0 ||
+        edgeChanges.length > 0 ||
+        topLevelChanges.length > 0;
+    return {
+        hasChanges,
+        nodes: nodeChanges,
+        edges: edgeChanges,
+        topLevel: topLevelChanges,
+    };
+}
+/**
+ * Compare nodes between local and remote plans
+ */
+function compareNodes(localNodes, remoteNodes) {
+    const changes = [];
+    // Build map of remote nodes by id
+    const remoteByID = new Map();
+    for (const node of remoteNodes) {
+        remoteByID.set(node.id, node);
+    }
+    const localIDs = new Set();
+    for (const node of localNodes) {
+        localIDs.add(node.id);
+    }
+    // Check local nodes
+    for (const local of localNodes) {
+        const remote = remoteByID.get(local.id);
+        if (!remote) {
+            // Node added
+            changes.push({
+                type: "add",
+                nodeId: local.id,
+                nodeType: local.type,
+                summary: getNodeSummary(local),
+                fieldChanges: [],
+            });
+        }
+        else {
+            // Node exists - check for modifications
+            const fieldChanges = compareNodeFields(local, remote);
+            if (fieldChanges.length > 0) {
+                changes.push({
+                    type: "modify",
+                    nodeId: local.id,
+                    nodeType: local.type,
+                    summary: getNodeSummary(local),
+                    fieldChanges,
+                });
+            }
+        }
+    }
+    // Check for removed nodes
+    for (const remote of remoteNodes) {
+        if (!localIDs.has(remote.id)) {
+            changes.push({
+                type: "remove",
+                nodeId: remote.id,
+                nodeType: remote.type,
+                summary: getNodeSummary(remote),
+                fieldChanges: [],
+            });
+        }
+    }
+    return changes;
+}
+/**
+ * Get a human-readable summary of a node
+ */
+function getNodeSummary(node) {
+    switch (node.type) {
+        case "ENDPOINT":
+            return `${node.method} ${formatValue(node.path)}`;
+        case "WAIT":
+            return `wait ${node.duration_ms}ms`;
+        case "ASSERTION":
+            return `${node.assertions.length} assertion(s)`;
+        default:
+            return node.type;
+    }
+}
+/**
+ * Format a value for display (handle VariableRef objects)
+ */
+function formatValue(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value &&
+        typeof value === "object" &&
+        "$variable" in value &&
+        typeof value.$variable === "object") {
+        return `$\{${value.$variable.key}}`;
+    }
+    return JSON.stringify(value);
+}
+/**
+ * Compare fields within two nodes of the same type
+ */
+function compareNodeFields(local, remote) {
+    const changes = [];
+    // Type should match, but check anyway
+    if (local.type !== remote.type) {
+        changes.push({
+            field: "type",
+            oldValue: remote.type,
+            newValue: local.type,
+        });
+        return changes;
+    }
+    switch (local.type) {
+        case "ENDPOINT":
+            compareEndpointFields(local, remote, changes);
+            break;
+        case "WAIT":
+            compareWaitFields(local, remote, changes);
+            break;
+        case "ASSERTION":
+            compareAssertionFields(local, remote, changes);
+            break;
+    }
+    return changes;
+}
+/**
+ * Compare fields specific to Endpoint nodes
+ */
+function compareEndpointFields(local, remote, changes) {
+    const fields = [
+        "method",
+        "path",
+        "base",
+        "headers",
+        "body",
+        "response_format",
+    ];
+    for (const field of fields) {
+        const localVal = local[field];
+        const remoteVal = remote[field];
+        if (!deepEqual(localVal, remoteVal)) {
+            changes.push({
+                field: field,
+                oldValue: remoteVal,
+                newValue: localVal,
+            });
+        }
+    }
+}
+/**
+ * Compare fields specific to Wait nodes
+ */
+function compareWaitFields(local, remote, changes) {
+    if (local.duration_ms !== remote.duration_ms) {
+        changes.push({
+            field: "duration_ms",
+            oldValue: remote.duration_ms,
+            newValue: local.duration_ms,
+        });
+    }
+}
+/**
+ * Compare fields specific to Assertion nodes
+ */
+function compareAssertionFields(local, remote, changes) {
+    if (!deepEqual(local.assertions, remote.assertions)) {
+        changes.push({
+            field: "assertions",
+            oldValue: remote.assertions,
+            newValue: local.assertions,
+        });
+    }
+}
+/**
+ * Compare edges between local and remote plans
+ */
+function compareEdges(localEdges, remoteEdges) {
+    const changes = [];
+    // Build map of remote edges by "from:to" key
+    const remoteByKey = new Map();
+    for (const edge of remoteEdges) {
+        remoteByKey.set(`${edge.from}:${edge.to}`, edge);
+    }
+    const localKeys = new Set();
+    for (const edge of localEdges) {
+        localKeys.add(`${edge.from}:${edge.to}`);
+    }
+    // Check local edges
+    for (const local of localEdges) {
+        const key = `${local.from}:${local.to}`;
+        if (!remoteByKey.has(key)) {
+            changes.push({
+                type: "add",
+                from: local.from,
+                to: local.to,
+            });
+        }
+    }
+    // Check for removed edges
+    for (const remote of remoteEdges) {
+        const key = `${remote.from}:${remote.to}`;
+        if (!localKeys.has(key)) {
+            changes.push({
+                type: "remove",
+                from: remote.from,
+                to: remote.to,
+            });
+        }
+    }
+    return changes;
+}
+/**
+ * Compare top-level fields: frequency, version, locations
+ */
+function compareTopLevel(local, remote) {
+    const changes = [];
+    // Compare frequency
+    if (!deepEqual(local.frequency, remote.frequency)) {
+        changes.push({
+            field: "frequency",
+            oldValue: remote.frequency,
+            newValue: local.frequency,
+        });
+    }
+    // Compare version
+    if (local.version !== remote.version) {
+        changes.push({
+            field: "version",
+            oldValue: remote.version,
+            newValue: local.version,
+        });
+    }
+    // Compare locations (normalize empty array to undefined)
+    const localLocations = local.locations;
+    const remoteLocations = remote.locations && remote.locations.length > 0
+        ? remote.locations
+        : undefined;
+    if (!deepEqual(localLocations, remoteLocations)) {
+        changes.push({
+            field: "locations",
+            oldValue: remoteLocations,
+            newValue: localLocations,
+        });
+    }
+    return changes;
+}
+/**
+ * Deep equality check using object-hash
+ */
+function deepEqual(a, b) {
+    return objectHash(a ?? null) === objectHash(b ?? null);
+}

package/dist/core/project.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Auto-detect project ID from the environment
+ *
+ * Priority:
+ * 1. package.json name field
+ * 2. Directory name
+ */
+export declare function detectProjectId(): Promise<string>;

package/dist/core/project.js

@@ -0,0 +1,46 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+/**
+ * Auto-detect project ID from the environment
+ *
+ * Priority:
+ * 1. package.json name field
+ * 2. Directory name
+ */
+export async function detectProjectId() {
+    try {
+        // Try to find package.json walking up from current directory
+        const packageJsonPath = await findPackageJson(process.cwd());
+        if (packageJsonPath) {
+            const content = await fs.readFile(packageJsonPath, "utf-8");
+            const pkg = JSON.parse(content);
+            if (pkg.name && typeof pkg.name === "string") {
+                return pkg.name;
+            }
+        }
+    }
+    catch (error) {
+        // Fall through to directory name
+    }
+    // Fallback to directory name
+    return path.basename(process.cwd());
+}
+/**
+ * Find package.json by walking up the directory tree
+ */
+async function findPackageJson(startDir) {
+    let currentDir = startDir;
+    const root = path.parse(currentDir).root;
+    while (currentDir !== root) {
+        const packageJsonPath = path.join(currentDir, "package.json");
+        try {
+            await fs.access(packageJsonPath);
+            return packageJsonPath;
+        }
+        catch {
+            // Not found, go up one level
+            currentDir = path.dirname(currentDir);
+        }
+    }
+    return null;
+}

package/dist/core/sdk.d.ts

@@ -0,0 +1,16 @@
+import { PlanApi, RunsApi } from "@griffin-app/griffin-hub-sdk";
+import type { TestPlanV1 } from "@griffin-app/griffin-ts/types";
+/**
+ * Create configured SDK API instances
+ */
+export declare function createSdkClients(config: {
+    baseUrl: string;
+    apiToken?: string;
+}): {
+    planApi: PlanApi;
+    runsApi: RunsApi;
+};
+/**
+ * Inject projectId into a plan payload before sending to runner
+ */
+export declare function injectProjectId(plan: Omit<TestPlanV1, "project">, projectId: string): TestPlanV1;

package/dist/core/sdk.js

@@ -0,0 +1,23 @@
+import { PlanApi, RunsApi, Configuration } from "@griffin-app/griffin-hub-sdk";
+/**
+ * Create configured SDK API instances
+ */
+export function createSdkClients(config) {
+    const configuration = new Configuration({
+        basePath: config.baseUrl.replace(/\/$/, ""), // Remove trailing slash
+        accessToken: config.apiToken,
+    });
+    return {
+        planApi: new PlanApi(configuration),
+        runsApi: new RunsApi(configuration),
+    };
+}
+/**
+ * Inject projectId into a plan payload before sending to runner
+ */
+export function injectProjectId(plan, projectId) {
+    return {
+        ...plan,
+        project: projectId,
+    };
+}

package/dist/core/state.d.ts

@@ -0,0 +1,52 @@
+import { type StateFile, type EnvironmentConfig } from "../schemas/state.js";
+export declare const STATE_DIR = ".griffin";
+export declare const STATE_FILE = "state.json";
+/**
+ * Get the state directory path (in current working directory)
+ */
+export declare function getStateDirPath(): string;
+/**
+ * Get the state file path
+ */
+export declare function getStateFilePath(): string;
+/**
+ * Check if state file exists
+ */
+export declare function stateExists(): Promise<boolean>;
+/**
+ * Load state file from disk
+ * Throws if file doesn't exist or is invalid
+ */
+export declare function loadState(): Promise<StateFile>;
+/**
+ * Save state file to disk
+ */
+export declare function saveState(state: StateFile): Promise<void>;
+/**
+ * Initialize a new state file
+ */
+export declare function initState(projectId: string): Promise<void>;
+/**
+ * Add or update an environment
+ */
+export declare function addEnvironment(name: string, config: EnvironmentConfig): Promise<void>;
+/**
+ * Remove an environment
+ */
+export declare function removeEnvironment(name: string): Promise<void>;
+/**
+ * Set the default environment
+ */
+export declare function setDefaultEnvironment(name: string): Promise<void>;
+/**
+ * Get the current environment name (from flag, env var, or default)
+ */
+export declare function resolveEnvironment(envFlag?: string): Promise<string>;
+/**
+ * Get environment configuration
+ */
+export declare function getEnvironment(name: string): Promise<EnvironmentConfig>;
+/**
+ * Get the project ID
+ */
+export declare function getProjectId(): Promise<string>;