flowspec 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,512 @@
+import { z } from "zod";
+/**
+ * Schema for step actions: visit, click, fill, select, wait_for
+ * Uses discriminated union to ensure exactly one action type per step
+ */
+export declare const StepActionSchema: z.ZodUnion<[z.ZodObject<{
+    visit: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    visit: string;
+}, {
+    visit: string;
+}>, z.ZodObject<{
+    click: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    click: string;
+}, {
+    click: string;
+}>, z.ZodObject<{
+    fill: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    fill: Record<string, string>;
+}, {
+    fill: Record<string, string>;
+}>, z.ZodObject<{
+    select: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    select: Record<string, string>;
+}, {
+    select: Record<string, string>;
+}>, z.ZodObject<{
+    wait_for: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    wait_for: string;
+}, {
+    wait_for: string;
+}>]>;
+export type StepAction = z.infer<typeof StepActionSchema>;
+/**
+ * Type guard for wait_for action
+ */
+export declare function isWaitForAction(action: StepAction): action is {
+    wait_for: string;
+};
+/**
+ * Schema for step assertions: url, visible, matches, not_visible
+ * Uses discriminated union to ensure exactly one assertion type
+ */
+export declare const StepAssertionSchema: z.ZodUnion<[z.ZodObject<{
+    url: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    url: string;
+}, {
+    url: string;
+}>, z.ZodObject<{
+    visible: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    visible: string;
+}, {
+    visible: string;
+}>, z.ZodObject<{
+    matches: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    matches: string;
+}, {
+    matches: string;
+}>, z.ZodObject<{
+    not_visible: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    not_visible: string;
+}, {
+    not_visible: string;
+}>]>;
+export type StepAssertion = z.infer<typeof StepAssertionSchema>;
+/**
+ * Schema for a flow step - currently identical to StepAction
+ * A step in a flow is simply an action to perform
+ */
+export declare const FlowStepSchema: z.ZodUnion<[z.ZodObject<{
+    visit: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    visit: string;
+}, {
+    visit: string;
+}>, z.ZodObject<{
+    click: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    click: string;
+}, {
+    click: string;
+}>, z.ZodObject<{
+    fill: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    fill: Record<string, string>;
+}, {
+    fill: Record<string, string>;
+}>, z.ZodObject<{
+    select: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    select: Record<string, string>;
+}, {
+    select: Record<string, string>;
+}>, z.ZodObject<{
+    wait_for: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    wait_for: string;
+}, {
+    wait_for: string;
+}>]>;
+export type FlowStep = z.infer<typeof FlowStepSchema>;
+/**
+ * Schema for a complete flow specification
+ * Defines a user flow with steps to execute and assertions to verify
+ */
+export declare const FlowSpecSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    steps: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        visit: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        visit: string;
+    }, {
+        visit: string;
+    }>, z.ZodObject<{
+        click: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        click: string;
+    }, {
+        click: string;
+    }>, z.ZodObject<{
+        fill: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        fill: Record<string, string>;
+    }, {
+        fill: Record<string, string>;
+    }>, z.ZodObject<{
+        select: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        select: Record<string, string>;
+    }, {
+        select: Record<string, string>;
+    }>, z.ZodObject<{
+        wait_for: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        wait_for: string;
+    }, {
+        wait_for: string;
+    }>]>, "many">;
+    expect: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        url: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        url: string;
+    }, {
+        url: string;
+    }>, z.ZodObject<{
+        visible: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        visible: string;
+    }, {
+        visible: string;
+    }>, z.ZodObject<{
+        matches: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        matches: string;
+    }, {
+        matches: string;
+    }>, z.ZodObject<{
+        not_visible: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        not_visible: string;
+    }, {
+        not_visible: string;
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    steps: ({
+        visit: string;
+    } | {
+        click: string;
+    } | {
+        fill: Record<string, string>;
+    } | {
+        select: Record<string, string>;
+    } | {
+        wait_for: string;
+    })[];
+    expect: ({
+        url: string;
+    } | {
+        visible: string;
+    } | {
+        matches: string;
+    } | {
+        not_visible: string;
+    })[];
+}, {
+    name: string;
+    description: string;
+    steps: ({
+        visit: string;
+    } | {
+        click: string;
+    } | {
+        fill: Record<string, string>;
+    } | {
+        select: Record<string, string>;
+    } | {
+        wait_for: string;
+    })[];
+    expect: ({
+        url: string;
+    } | {
+        visible: string;
+    } | {
+        matches: string;
+    } | {
+        not_visible: string;
+    })[];
+}>;
+export type FlowSpec = z.infer<typeof FlowSpecSchema>;
+/**
+ * Schema for flow execution errors
+ * Can describe either a step failure or an assertion failure
+ */
+export declare const FlowErrorSchema: z.ZodObject<{
+    message: z.ZodString;
+    step: z.ZodOptional<z.ZodNumber>;
+    action: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        visit: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        visit: string;
+    }, {
+        visit: string;
+    }>, z.ZodObject<{
+        click: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        click: string;
+    }, {
+        click: string;
+    }>, z.ZodObject<{
+        fill: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        fill: Record<string, string>;
+    }, {
+        fill: Record<string, string>;
+    }>, z.ZodObject<{
+        select: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        select: Record<string, string>;
+    }, {
+        select: Record<string, string>;
+    }>, z.ZodObject<{
+        wait_for: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        wait_for: string;
+    }, {
+        wait_for: string;
+    }>]>>;
+    assertion: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        url: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        url: string;
+    }, {
+        url: string;
+    }>, z.ZodObject<{
+        visible: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        visible: string;
+    }, {
+        visible: string;
+    }>, z.ZodObject<{
+        matches: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        matches: string;
+    }, {
+        matches: string;
+    }>, z.ZodObject<{
+        not_visible: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        not_visible: string;
+    }, {
+        not_visible: string;
+    }>]>>;
+    screenshot: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    step?: number | undefined;
+    action?: {
+        visit: string;
+    } | {
+        click: string;
+    } | {
+        fill: Record<string, string>;
+    } | {
+        select: Record<string, string>;
+    } | {
+        wait_for: string;
+    } | undefined;
+    assertion?: {
+        url: string;
+    } | {
+        visible: string;
+    } | {
+        matches: string;
+    } | {
+        not_visible: string;
+    } | undefined;
+    screenshot?: string | undefined;
+}, {
+    message: string;
+    step?: number | undefined;
+    action?: {
+        visit: string;
+    } | {
+        click: string;
+    } | {
+        fill: Record<string, string>;
+    } | {
+        select: Record<string, string>;
+    } | {
+        wait_for: string;
+    } | undefined;
+    assertion?: {
+        url: string;
+    } | {
+        visible: string;
+    } | {
+        matches: string;
+    } | {
+        not_visible: string;
+    } | undefined;
+    screenshot?: string | undefined;
+}>;
+export type FlowError = z.infer<typeof FlowErrorSchema>;
+/**
+ * Schema for flow execution results
+ * Contains success status, timing, and optional error details
+ */
+export declare const FlowResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    flowName: z.ZodString;
+    duration: z.ZodNumber;
+    error: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        step: z.ZodOptional<z.ZodNumber>;
+        action: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+            visit: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            visit: string;
+        }, {
+            visit: string;
+        }>, z.ZodObject<{
+            click: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            click: string;
+        }, {
+            click: string;
+        }>, z.ZodObject<{
+            fill: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            fill: Record<string, string>;
+        }, {
+            fill: Record<string, string>;
+        }>, z.ZodObject<{
+            select: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            select: Record<string, string>;
+        }, {
+            select: Record<string, string>;
+        }>, z.ZodObject<{
+            wait_for: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            wait_for: string;
+        }, {
+            wait_for: string;
+        }>]>>;
+        assertion: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+            url: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            url: string;
+        }, {
+            url: string;
+        }>, z.ZodObject<{
+            visible: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            visible: string;
+        }, {
+            visible: string;
+        }>, z.ZodObject<{
+            matches: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            matches: string;
+        }, {
+            matches: string;
+        }>, z.ZodObject<{
+            not_visible: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            not_visible: string;
+        }, {
+            not_visible: string;
+        }>]>>;
+        screenshot: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        step?: number | undefined;
+        action?: {
+            visit: string;
+        } | {
+            click: string;
+        } | {
+            fill: Record<string, string>;
+        } | {
+            select: Record<string, string>;
+        } | {
+            wait_for: string;
+        } | undefined;
+        assertion?: {
+            url: string;
+        } | {
+            visible: string;
+        } | {
+            matches: string;
+        } | {
+            not_visible: string;
+        } | undefined;
+        screenshot?: string | undefined;
+    }, {
+        message: string;
+        step?: number | undefined;
+        action?: {
+            visit: string;
+        } | {
+            click: string;
+        } | {
+            fill: Record<string, string>;
+        } | {
+            select: Record<string, string>;
+        } | {
+            wait_for: string;
+        } | undefined;
+        assertion?: {
+            url: string;
+        } | {
+            visible: string;
+        } | {
+            matches: string;
+        } | {
+            not_visible: string;
+        } | undefined;
+        screenshot?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    flowName: string;
+    duration: number;
+    error?: {
+        message: string;
+        step?: number | undefined;
+        action?: {
+            visit: string;
+        } | {
+            click: string;
+        } | {
+            fill: Record<string, string>;
+        } | {
+            select: Record<string, string>;
+        } | {
+            wait_for: string;
+        } | undefined;
+        assertion?: {
+            url: string;
+        } | {
+            visible: string;
+        } | {
+            matches: string;
+        } | {
+            not_visible: string;
+        } | undefined;
+        screenshot?: string | undefined;
+    } | undefined;
+}, {
+    success: boolean;
+    flowName: string;
+    duration: number;
+    error?: {
+        message: string;
+        step?: number | undefined;
+        action?: {
+            visit: string;
+        } | {
+            click: string;
+        } | {
+            fill: Record<string, string>;
+        } | {
+            select: Record<string, string>;
+        } | {
+            wait_for: string;
+        } | undefined;
+        assertion?: {
+            url: string;
+        } | {
+            visible: string;
+        } | {
+            matches: string;
+        } | {
+            not_visible: string;
+        } | undefined;
+        screenshot?: string | undefined;
+    } | undefined;
+}>;
+export type FlowResult = z.infer<typeof FlowResultSchema>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAM3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;GAEG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,UAAU,GACjB,MAAM,IAAI;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAEhC;AAUD;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;IAK9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAmB,CAAC;AAE/C,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKzB,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/types.js

@@ -0,0 +1,78 @@
+import { z } from "zod";
+// Action schemas - each action type is a distinct object shape
+const VisitActionSchema = z.object({ visit: z.string() }).strict();
+const ClickActionSchema = z.object({ click: z.string() }).strict();
+const FillActionSchema = z.object({ fill: z.record(z.string()) }).strict();
+const SelectActionSchema = z.object({ select: z.record(z.string()) }).strict();
+const WaitForActionSchema = z.object({ wait_for: z.string() }).strict();
+/**
+ * Schema for step actions: visit, click, fill, select, wait_for
+ * Uses discriminated union to ensure exactly one action type per step
+ */
+export const StepActionSchema = z.union([
+    VisitActionSchema,
+    ClickActionSchema,
+    FillActionSchema,
+    SelectActionSchema,
+    WaitForActionSchema,
+]);
+/**
+ * Type guard for wait_for action
+ */
+export function isWaitForAction(action) {
+    return "wait_for" in action;
+}
+// Assertion schemas - each assertion type is a distinct object shape
+const UrlAssertionSchema = z.object({ url: z.string() }).strict();
+const VisibleAssertionSchema = z.object({ visible: z.string() }).strict();
+const MatchesAssertionSchema = z.object({ matches: z.string() }).strict();
+const NotVisibleAssertionSchema = z
+    .object({ not_visible: z.string() })
+    .strict();
+/**
+ * Schema for step assertions: url, visible, matches, not_visible
+ * Uses discriminated union to ensure exactly one assertion type
+ */
+export const StepAssertionSchema = z.union([
+    UrlAssertionSchema,
+    VisibleAssertionSchema,
+    MatchesAssertionSchema,
+    NotVisibleAssertionSchema,
+]);
+/**
+ * Schema for a flow step - currently identical to StepAction
+ * A step in a flow is simply an action to perform
+ */
+export const FlowStepSchema = StepActionSchema;
+/**
+ * Schema for a complete flow specification
+ * Defines a user flow with steps to execute and assertions to verify
+ */
+export const FlowSpecSchema = z.object({
+    name: z.string(),
+    description: z.string(),
+    steps: z.array(FlowStepSchema).min(1),
+    expect: z.array(StepAssertionSchema).min(1),
+});
+/**
+ * Schema for flow execution errors
+ * Can describe either a step failure or an assertion failure
+ */
+export const FlowErrorSchema = z.object({
+    message: z.string(),
+    step: z.number().optional(),
+    action: StepActionSchema.optional(),
+    assertion: StepAssertionSchema.optional(),
+    screenshot: z.string().optional(),
+});
+/**
+ * Schema for flow execution results
+ * Contains success status, timing, and optional error details
+ */
+export const FlowResultSchema = z.object({
+    success: z.boolean(),
+    flowName: z.string(),
+    duration: z.number(),
+    error: FlowErrorSchema.optional(),
+});
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "flowspec",
+  "version": "0.1.0",
+  "description": "Immutable user flow specifications for the age of agentic coding",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "flowspec": "./dist/index.js"
+  },
+  "files": ["dist"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/queso/FlowSpec"
+  },
+  "keywords": ["testing", "e2e", "flow", "specs", "yaml", "claude", "ai"],
+  "author": "Josh Owens",
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "build": "tsc",
+    "prepublishOnly": "bun run build",
+    "test": "vitest",
+    "test:coverage": "vitest --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "format": "biome format --write ."
+  },
+  "dependencies": {
+    "agent-browser": "^0.1.0",
+    "js-yaml": "^4.1.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.13",
+    "@types/express": "^4.17.0",
+    "@types/js-yaml": "^4.0.0",
+    "@vitest/coverage-v8": "^1.0.0",
+    "express": "^4.18.0",
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "MIT"
+}