@tailor-platform/erp-kit 0.5.1 → 0.7.0

package/src/progress/schema.ts

@@ -0,0 +1,316 @@
+import { z } from "zod";
+
+// === Enums ===
+
+export const EventType = z.enum([
+  "step.start",
+  "step.complete",
+  "decision",
+  "agent.dispatch",
+  "agent.result",
+  "artifact.create",
+  "validation",
+  "error",
+  "note",
+]);
+
+export const StepStatus = z.enum(["pass", "fail", "blocked"]);
+
+export const ArtifactType = z.enum(["doc", "code", "config", "report", "seed", "asset"]);
+
+export const ArtifactOperation = z.enum(["create", "update", "delete"]);
+
+// === Conversation ===
+
+export const ConversationMessage = z.object({
+  role: z.enum(["user", "agent"]),
+  message: z.string(),
+});
+
+// === Git context (auto-captured by CLI) ===
+
+export const GitContext = z.object({
+  branch: z.string(),
+  commit: z.string(),
+});
+
+// === Event data payloads ===
+
+export const StepStartData = z.object({
+  skill: z.string(),
+  context: z.record(z.string(), z.unknown()),
+});
+
+export const StepCompleteData = z.object({
+  status: StepStatus,
+  summary: z.string(),
+  artifacts: z.array(z.string()),
+});
+
+export const DecisionData = z.object({
+  question: z.string(),
+  choice: z.string(),
+  alternatives: z.array(z.string()),
+  rationale: z.string(),
+});
+
+export const AgentDispatchData = z.object({
+  agentName: z.string(),
+  task: z.string(),
+  inputs: z.record(z.string(), z.unknown()),
+});
+
+export const AgentResultData = z.object({
+  agentName: z.string(),
+  status: z.enum(["pass", "fail"]),
+  outputs: z.record(z.string(), z.unknown()),
+  duration_ms: z.number(),
+});
+
+export const ArtifactCreateData = z.object({
+  path: z.string(),
+  type: ArtifactType,
+  operation: ArtifactOperation,
+});
+
+export const ValidationData = z.object({
+  command: z.string(),
+  status: z.enum(["pass", "fail"]),
+  issues: z.array(z.string()),
+});
+
+export const ErrorData = z.object({
+  message: z.string(),
+  recoverable: z.boolean(),
+});
+
+export const NoteData = z.object({
+  message: z.string(),
+  tags: z.array(z.string()),
+});
+
+// === Flattened entry schemas ===
+// Each variant is a complete object (no .and() intersection)
+// to avoid Zod 4 issues with union + intersection.
+//
+// conversation field is recreated per schema to avoid sharing a .default()
+// schema instance across multiple union members (Zod 4 limitation).
+
+const convField = () => z.array(ConversationMessage).default([]);
+
+// --- Entry schemas (stored in JSONL) ---
+
+export const StepStartEntry = z.object({
+  v: z.literal(1),
+  timestamp: z.string().datetime(),
+  sessionId: z.string(),
+  prompt: z.string(),
+  git: GitContext,
+  conversation: convField(),
+  event: z.literal("step.start"),
+  data: StepStartData,
+});
+
+export const StepCompleteEntry = z.object({
+  v: z.literal(1),
+  timestamp: z.string().datetime(),
+  sessionId: z.string(),
+  prompt: z.string(),
+  git: GitContext,
+  conversation: convField(),
+  event: z.literal("step.complete"),
+  data: StepCompleteData,
+});
+
+export const DecisionEntry = z.object({
+  v: z.literal(1),
+  timestamp: z.string().datetime(),
+  sessionId: z.string(),
+  prompt: z.string(),
+  git: GitContext,
+  conversation: convField(),
+  event: z.literal("decision"),
+  data: DecisionData,
+});
+
+export const AgentDispatchEntry = z.object({
+  v: z.literal(1),
+  timestamp: z.string().datetime(),
+  sessionId: z.string(),
+  prompt: z.string(),
+  git: GitContext,
+  conversation: convField(),
+  event: z.literal("agent.dispatch"),
+  data: AgentDispatchData,
+});
+
+export const AgentResultEntry = z.object({
+  v: z.literal(1),
+  timestamp: z.string().datetime(),
+  sessionId: z.string(),
+  prompt: z.string(),
+  git: GitContext,
+  conversation: convField(),
+  event: z.literal("agent.result"),
+  data: AgentResultData,
+});
+
+export const ArtifactCreateEntry = z.object({
+  v: z.literal(1),
+  timestamp: z.string().datetime(),
+  sessionId: z.string(),
+  prompt: z.string(),
+  git: GitContext,
+  conversation: convField(),
+  event: z.literal("artifact.create"),
+  data: ArtifactCreateData,
+});
+
+export const ValidationEntry = z.object({
+  v: z.literal(1),
+  timestamp: z.string().datetime(),
+  sessionId: z.string(),
+  prompt: z.string(),
+  git: GitContext,
+  conversation: convField(),
+  event: z.literal("validation"),
+  data: ValidationData,
+});
+
+export const ErrorEntry = z.object({
+  v: z.literal(1),
+  timestamp: z.string().datetime(),
+  sessionId: z.string(),
+  prompt: z.string(),
+  git: GitContext,
+  conversation: convField(),
+  event: z.literal("error"),
+  data: ErrorData,
+});
+
+export const NoteEntry = z.object({
+  v: z.literal(1),
+  timestamp: z.string().datetime(),
+  sessionId: z.string(),
+  prompt: z.string(),
+  git: GitContext,
+  conversation: convField(),
+  event: z.literal("note"),
+  data: NoteData,
+});
+
+// z.union auto-detects the "event" discriminator in Zod 4
+export const ProgressEntry = z.union([
+  StepStartEntry,
+  StepCompleteEntry,
+  DecisionEntry,
+  AgentDispatchEntry,
+  AgentResultEntry,
+  ArtifactCreateEntry,
+  ValidationEntry,
+  ErrorEntry,
+  NoteEntry,
+]);
+
+// --- Input schemas (what skills pass to CLI, no timestamp/git) ---
+
+export const StepStartInput = z.object({
+  v: z.literal(1),
+  sessionId: z.string(),
+  prompt: z.string(),
+  conversation: convField(),
+  event: z.literal("step.start"),
+  data: StepStartData,
+});
+
+export const StepCompleteInput = z.object({
+  v: z.literal(1),
+  sessionId: z.string(),
+  prompt: z.string(),
+  conversation: convField(),
+  event: z.literal("step.complete"),
+  data: StepCompleteData,
+});
+
+export const DecisionInput = z.object({
+  v: z.literal(1),
+  sessionId: z.string(),
+  prompt: z.string(),
+  conversation: convField(),
+  event: z.literal("decision"),
+  data: DecisionData,
+});
+
+export const AgentDispatchInput = z.object({
+  v: z.literal(1),
+  sessionId: z.string(),
+  prompt: z.string(),
+  conversation: convField(),
+  event: z.literal("agent.dispatch"),
+  data: AgentDispatchData,
+});
+
+export const AgentResultInput = z.object({
+  v: z.literal(1),
+  sessionId: z.string(),
+  prompt: z.string(),
+  conversation: convField(),
+  event: z.literal("agent.result"),
+  data: AgentResultData,
+});
+
+export const ArtifactCreateInput = z.object({
+  v: z.literal(1),
+  sessionId: z.string(),
+  prompt: z.string(),
+  conversation: convField(),
+  event: z.literal("artifact.create"),
+  data: ArtifactCreateData,
+});
+
+export const ValidationInput = z.object({
+  v: z.literal(1),
+  sessionId: z.string(),
+  prompt: z.string(),
+  conversation: convField(),
+  event: z.literal("validation"),
+  data: ValidationData,
+});
+
+export const ErrorInput = z.object({
+  v: z.literal(1),
+  sessionId: z.string(),
+  prompt: z.string(),
+  conversation: convField(),
+  event: z.literal("error"),
+  data: ErrorData,
+});
+
+export const NoteInput = z.object({
+  v: z.literal(1),
+  sessionId: z.string(),
+  prompt: z.string(),
+  conversation: convField(),
+  event: z.literal("note"),
+  data: NoteData,
+});
+
+export const ProgressInput = z.union([
+  StepStartInput,
+  StepCompleteInput,
+  DecisionInput,
+  AgentDispatchInput,
+  AgentResultInput,
+  ArtifactCreateInput,
+  ValidationInput,
+  ErrorInput,
+  NoteInput,
+]);
+
+// === Inferred types ===
+
+export type EventType = z.infer<typeof EventType>;
+export type ConversationMessage = z.infer<typeof ConversationMessage>;
+export type GitContext = z.infer<typeof GitContext>;
+export type ProgressEntry = z.infer<typeof ProgressEntry>;
+export type ProgressInput = z.infer<typeof ProgressInput>;

package/templates/scaffold/app/backend/package.json

@@ -10,7 +10,9 @@
     "lint:fix": "eslint --cache --fix .",
     "seed": "node --env-file-if-exists=.env seed/exec.mjs",
     "seed:reset": "node --env-file-if-exists=.env seed/exec.mjs --truncate --yes",
-    "typecheck": "tsc --noEmit"
+    "test:integration": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "gql-tada:check": "gql-tada check"
   },
   "dependencies": {
     "@tailor-platform/erp-kit": "workspace:*",
@@ -24,7 +26,10 @@
     "eslint": "10.0.3",
     "eslint-import-resolver-typescript": "4.4.4",
     "eslint-plugin-import-x": "4.16.2",
+    "gql.tada": "1.9.0",
     "typescript": "5.9.3",
-    "typescript-eslint": "8.57.0"
+    "typescript-eslint": "8.57.0",
+    "urql": "5.0.1",
+    "vitest": "4.0.18"
   }
 }

package/templates/scaffold/app/backend/src/tests/utils/graphql-client.ts

@@ -0,0 +1,66 @@
+import { initGraphQLTada } from "gql.tada";
+import { createClient, Client, fetchExchange } from "urql";
+import type { OperationResult } from "urql";
+
+import type { introspection } from "../../../../frontend/src/graphql/generated/graphql-env.d";
+
+export const graphql = initGraphQLTada<{
+  introspection: introspection;
+  scalars: {
+    DateTime: string;
+    Date: string;
+    Time: string;
+  };
+}>();
+
+export type { FragmentOf, ResultOf, VariablesOf } from "gql.tada";
+
+export function createGraphQLClient(appUrl: string, token: string): Client {
+  const endpoint = new URL("/query", appUrl).href;
+
+  const client = createClient({
+    url: endpoint,
+    exchanges: [fetchExchange],
+    requestPolicy: "network-only",
+    preferGetMethod: false,
+    fetchOptions: () => ({
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+      },
+    }),
+  });
+
+  const wrapToPromise = <T extends OperationResult>(originalToPromise: () => Promise<T>) => {
+    return async (): Promise<T> => {
+      const result = await originalToPromise();
+      if (result.error) {
+        throw result.error;
+      }
+      return result;
+    };
+  };
+
+  return {
+    ...client,
+    mutation: <Data = unknown, Variables extends Record<string, unknown> = Record<string, unknown>>(
+      query: string,
+      variables?: Variables,
+    ) => {
+      const original = client.mutation<Data, Variables>(query, variables!);
+      return Object.assign(original, {
+        toPromise: wrapToPromise(original.toPromise.bind(original)),
+      });
+    },
+    query: <Data = unknown, Variables extends Record<string, unknown> = Record<string, unknown>>(
+      query: string,
+      variables?: Variables,
+    ) => {
+      const original = client.query<Data, Variables>(query, variables!);
+      return Object.assign(original, {
+        toPromise: wrapToPromise(original.toPromise.bind(original)),
+      });
+    },
+  } as Client;
+}

package/templates/scaffold/app/backend/src/tests/utils/setup.ts

@@ -0,0 +1,21 @@
+import type { TestProject } from "vitest/node";
+import { show, listMachineUsers, getMachineUserToken } from "@tailor-platform/sdk/cli";
+
+declare module "vitest" {
+  export interface ProvidedContext {
+    url: string;
+    token: string;
+  }
+}
+
+export async function setup(project: TestProject) {
+  const app = await show();
+  const url = app.url;
+
+  const machineUsers = await listMachineUsers();
+  const tokens = await getMachineUserToken({ name: machineUsers[0].name });
+  const token = tokens.accessToken;
+
+  project.provide("url", url);
+  project.provide("token", token);
+}

package/templates/scaffold/app/backend/tsconfig.json

@@ -10,10 +10,17 @@
     "noEmit": true,
     "skipLibCheck": true,
     "resolveJsonModule": true,
-    "types": ["node", "@tailor-platform/function-types"],
+    "types": ["node", "@tailor-platform/function-types", "vitest/globals"],
     "paths": {
       "@/*": ["./src/*"]
-    }
+    },
+    "plugins": [
+      {
+        "name": "gql.tada/ts-plugin",
+        "schema": "../frontend/src/graphql/generated/schema.graphql",
+        "tadaOutputLocation": "../frontend/src/graphql/generated/graphql-env.d.ts"
+      }
+    ]
   },
   "include": ["**/*.ts"]
 }

package/templates/scaffold/app/backend/vitest.config.ts

@@ -0,0 +1,18 @@
+import path from "path";
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"),
+    },
+  },
+  test: {
+    watch: false,
+    passWithNoTests: true,
+    environment: "node",
+    include: ["./src/tests/**/*.test.ts"],
+    globalSetup: ["./src/tests/utils/setup.ts"],
+    testTimeout: 60_000,
+  },
+});

package/templates/scaffold/app/frontend/package.json

@@ -10,7 +10,7 @@
     "gql-tada:check": "gql-tada check -c tsconfig.app.json",
     "lint": "eslint .",
     "lint:fix": "eslint --fix .",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc -b"
   },
   "dependencies": {
     "@hookform/resolvers": "5.2.2",
@@ -30,7 +30,7 @@
   },
   "devDependencies": {
     "@eslint/js": "10.0.1",
-    "@rolldown/plugin-babel": "0.2.1",
+    "@rolldown/plugin-babel": "0.2.2",
     "@tailor-platform/app-shell-vite-plugin": "0.1.0",
     "@tailwindcss/vite": "4.2.1",
     "@types/node": "25.5.0",

package/src/generator/generate-stubs.ts

@@ -1,31 +0,0 @@
-import { renderStub } from "./stub-templates";
-
-export function generateCommandStub(doc: { commandName: string }): string {
-  return renderStub("command", doc.commandName);
-}
-
-export function generateTestStub(doc: { commandName: string }): string {
-  return renderStub("commandTest", doc.commandName);
-}
-
-export function generateQueryStub(doc: { commandName: string }): string {
-  return renderStub("query", doc.commandName);
-}
-
-export function generateQueryTestStub(doc: { commandName: string }): string {
-  return renderStub("queryTest", doc.commandName);
-}
-
-export function generateDbStub(modelName: string): string {
-  return renderStub("db", modelName);
-}
-
-export function generateResolverStub(resolverName: string): string {
-  return renderStub("resolver", resolverName);
-}
-
-export function generateResolverTestStub(resolverName: string): string {
-  return renderStub("resolverTest", resolverName);
-}
-
-export { renderStub, type StubType } from "./stub-templates";