@tailor-platform/erp-kit 0.6.0 → 0.8.0

package/src/progress/schema.test.ts

@@ -0,0 +1,161 @@
+import { describe, it, expect } from "vitest";
+import { ProgressInput, ProgressEntry } from "./schema";
+
+describe("ProgressInput", () => {
+  it("accepts a valid step.start input", () => {
+    const input = {
+      v: 1,
+      sessionId: "s1",
+      prompt: "Create requirements for manufacturing",
+      event: "step.start" as const,
+      data: {
+        skill: "erp-kit-app-1-requirements",
+        context: { industry: "manufacturing" },
+      },
+    };
+    const result = ProgressInput.safeParse(input);
+    expect(result.success).toBe(true);
+  });
+
+  it("defaults conversation to empty array when omitted", () => {
+    const input = {
+      v: 1,
+      sessionId: "s1",
+      prompt: "Create screens for manufacturing",
+      event: "decision" as const,
+      data: {
+        question: "Flat or tree?",
+        choice: "tree",
+        alternatives: ["flat"],
+        rationale: "better UX",
+      },
+    };
+    const result = ProgressInput.safeParse(input);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.conversation).toEqual([]);
+    }
+  });
+
+  it("rejects missing prompt", () => {
+    const input = {
+      v: 1,
+      sessionId: "s1",
+      event: "note" as const,
+      data: { message: "test", tags: [] },
+    };
+    const result = ProgressInput.safeParse(input);
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects invalid event type", () => {
+    const input = {
+      v: 1,
+      sessionId: "s1",
+      prompt: "some prompt",
+      event: "invalid.event",
+      data: {},
+    };
+    const result = ProgressInput.safeParse(input);
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects mismatched event/data", () => {
+    const input = {
+      v: 1,
+      sessionId: "s1",
+      prompt: "some prompt",
+      event: "step.start" as const,
+      data: {
+        question: "something",
+        choice: "something",
+        alternatives: [],
+        rationale: "",
+      },
+    };
+    const result = ProgressInput.safeParse(input);
+    expect(result.success).toBe(false);
+  });
+
+  it("accepts all event types with correct data", () => {
+    const events = [
+      { event: "step.start", data: { skill: "s", context: {} } },
+      { event: "step.complete", data: { status: "pass", summary: "done", artifacts: [] } },
+      { event: "decision", data: { question: "q", choice: "c", alternatives: [], rationale: "r" } },
+      { event: "agent.dispatch", data: { agentName: "a", task: "t", inputs: {} } },
+      {
+        event: "agent.result",
+        data: { agentName: "a", status: "pass", outputs: {}, duration_ms: 100 },
+      },
+      { event: "artifact.create", data: { path: "f.md", type: "doc", operation: "create" } },
+      { event: "validation", data: { command: "check", status: "pass", issues: [] } },
+      { event: "error", data: { message: "err", recoverable: true } },
+      { event: "note", data: { message: "note", tags: ["tag"] } },
+    ];
+    for (const { event, data } of events) {
+      const result = ProgressInput.safeParse({
+        v: 1,
+        sessionId: "s1",
+        prompt: "test prompt",
+        event,
+        data,
+      });
+      expect(result.success, `event "${event}" should be valid`).toBe(true);
+    }
+  });
+
+  it("accepts conversation messages", () => {
+    const input = {
+      v: 1,
+      sessionId: "s1",
+      prompt: "test prompt",
+      event: "decision" as const,
+      conversation: [
+        { role: "user" as const, message: "flat or tree?" },
+        { role: "agent" as const, message: "I recommend tree" },
+      ],
+      data: {
+        question: "layout",
+        choice: "tree",
+        alternatives: ["flat"],
+        rationale: "better UX",
+      },
+    };
+    const result = ProgressInput.safeParse(input);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.conversation).toHaveLength(2);
+    }
+  });
+});
+
+describe("ProgressEntry", () => {
+  it("accepts a full entry with timestamp and git", () => {
+    const entry = {
+      v: 1,
+      timestamp: "2026-03-21T10:00:00.000Z",
+      sessionId: "s1",
+      prompt: "test prompt",
+      event: "note" as const,
+      git: { branch: "main", commit: "abc123" },
+      conversation: [],
+      data: { message: "test", tags: [] },
+    };
+    const result = ProgressEntry.safeParse(entry);
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects entry without timestamp", () => {
+    const entry = {
+      v: 1,
+      sessionId: "s1",
+      prompt: "test prompt",
+      event: "note" as const,
+      git: { branch: "main", commit: "abc123" },
+      conversation: [],
+      data: { message: "test", tags: [] },
+    };
+    const result = ProgressEntry.safeParse(entry);
+    expect(result.success).toBe(false);
+  });
+});

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,9 +10,7 @@
     "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",
-    "test": "vitest run --project unit",
-    "test:unit": "vitest run --project unit",
-    "test:integration": "vitest run --project integration",
+    "test:integration": "vitest run",
     "typecheck": "tsc --noEmit",
     "gql-tada:check": "gql-tada check"
   },

package/templates/scaffold/app/backend/seed/data/AuditEntry.schema.ts

@@ -0,0 +1,20 @@
+import { t } from "@tailor-platform/sdk";
+import { defineSchema } from "@tailor-platform/sdk/seed";
+import { createTailorDBHook, createStandardSchema } from "@tailor-platform/sdk/test";
+import { auditEntry } from "../../src/modules-db";
+
+const schemaType = t.object({
+  ...auditEntry.pickFields(["id","createdAt"], { optional: true }),
+  ...auditEntry.omitFields(["id","createdAt"]),
+});
+
+const hook = createTailorDBHook(auditEntry);
+
+export const schema = defineSchema(
+  createStandardSchema(schemaType, hook),
+  {
+    indexes: [
+      {"name":"auditentry_eventId_unique_idx","columns":["eventId"],"unique":true},
+    ],
+  }
+);

package/templates/scaffold/app/backend/seed/data/AuditPolicy.jsonl

@@ -0,0 +1,7 @@
+{"id":"00000000-0000-0000-0200-000000000001","entityName":"User","companyId":null,"operationType":"CREATE","status":"ACTIVE"}
+{"id":"00000000-0000-0000-0200-000000000002","entityName":"User","companyId":null,"operationType":"UPDATE","status":"ACTIVE"}
+{"id":"00000000-0000-0000-0200-000000000003","entityName":"Role","companyId":null,"operationType":"CREATE","status":"ACTIVE"}
+{"id":"00000000-0000-0000-0200-000000000004","entityName":"UserRole","companyId":null,"operationType":"CREATE","status":"ACTIVE"}
+{"id":"00000000-0000-0000-0200-000000000005","entityName":"UserRole","companyId":null,"operationType":"DELETE","status":"ACTIVE"}
+{"id":"00000000-0000-0000-0200-000000000006","entityName":"RolePermission","companyId":null,"operationType":"CREATE","status":"ACTIVE"}
+{"id":"00000000-0000-0000-0200-000000000007","entityName":"RolePermission","companyId":null,"operationType":"DELETE","status":"ACTIVE"}

package/templates/scaffold/app/backend/seed/data/AuditPolicy.schema.ts

@@ -0,0 +1,15 @@
+import { t } from "@tailor-platform/sdk";
+import { defineSchema } from "@tailor-platform/sdk/seed";
+import { createTailorDBHook, createStandardSchema } from "@tailor-platform/sdk/test";
+import { auditPolicy } from "../../src/modules-db";
+
+const schemaType = t.object({
+  ...auditPolicy.pickFields(["id","createdAt"], { optional: true }),
+  ...auditPolicy.omitFields(["id","createdAt"]),
+});
+
+const hook = createTailorDBHook(auditPolicy);
+
+export const schema = defineSchema(
+  createStandardSchema(schemaType, hook),
+);

package/templates/scaffold/app/backend/seed/data/AuditableEntity.jsonl

@@ -0,0 +1,4 @@
+{"id":"00000000-0000-0000-0100-000000000001","entityName":"User","entityScope":"GLOBAL","auditableFields":"[{\"fieldName\":\"name\"},{\"fieldName\":\"email\"},{\"fieldName\":\"status\"}]"}
+{"id":"00000000-0000-0000-0100-000000000002","entityName":"Role","entityScope":"GLOBAL","auditableFields":"[{\"fieldName\":\"name\"},{\"fieldName\":\"description\"}]"}
+{"id":"00000000-0000-0000-0100-000000000003","entityName":"UserRole","entityScope":"GLOBAL","auditableFields":"[{\"fieldName\":\"userId\"},{\"fieldName\":\"roleId\"}]"}
+{"id":"00000000-0000-0000-0100-000000000004","entityName":"RolePermission","entityScope":"GLOBAL","auditableFields":"[{\"fieldName\":\"roleId\"},{\"fieldName\":\"permissionId\"}]"}

package/templates/scaffold/app/backend/seed/data/AuditableEntity.schema.ts

@@ -0,0 +1,20 @@
+import { t } from "@tailor-platform/sdk";
+import { defineSchema } from "@tailor-platform/sdk/seed";
+import { createTailorDBHook, createStandardSchema } from "@tailor-platform/sdk/test";
+import { auditableEntity } from "../../src/modules-db";
+
+const schemaType = t.object({
+  ...auditableEntity.pickFields(["id","createdAt"], { optional: true }),
+  ...auditableEntity.omitFields(["id","createdAt"]),
+});
+
+const hook = createTailorDBHook(auditableEntity);
+
+export const schema = defineSchema(
+  createStandardSchema(schemaType, hook),
+  {
+    indexes: [
+      {"name":"auditableentity_entityName_unique_idx","columns":["entityName"],"unique":true},
+    ],
+  }
+);

package/templates/scaffold/app/backend/seed/data/ChangeDetail.schema.ts

@@ -0,0 +1,20 @@
+import { t } from "@tailor-platform/sdk";
+import { defineSchema } from "@tailor-platform/sdk/seed";
+import { createTailorDBHook, createStandardSchema } from "@tailor-platform/sdk/test";
+import { changeDetail } from "../../src/modules-db";
+
+const schemaType = t.object({
+  ...changeDetail.pickFields(["id","createdAt"], { optional: true }),
+  ...changeDetail.omitFields(["id","createdAt"]),
+});
+
+const hook = createTailorDBHook(changeDetail);
+
+export const schema = defineSchema(
+  createStandardSchema(schemaType, hook),
+  {
+    foreignKeys: [
+      {"column":"auditEntryId","references":{"table":"AuditEntry","column":"id"}},
+    ],
+  }
+);

package/templates/scaffold/app/backend/seed/data/Company.schema.ts

@@ -0,0 +1,15 @@
+import { t } from "@tailor-platform/sdk";
+import { defineSchema } from "@tailor-platform/sdk/seed";
+import { createTailorDBHook, createStandardSchema } from "@tailor-platform/sdk/test";
+import { company } from "../../src/modules-db";
+
+const schemaType = t.object({
+  ...company.pickFields(["id"], { optional: true }),
+  ...company.omitFields(["id"]),
+});
+
+const hook = createTailorDBHook(company);
+
+export const schema = defineSchema(
+  createStandardSchema(schemaType, hook),
+);

package/templates/scaffold/app/backend/seed/data/Permission.jsonl

@@ -0,0 +1,13 @@
+{"id":"00000000-0000-0000-0000-000000000001","key":"user-management:createUser","description":"Create user accounts"}
+{"id":"00000000-0000-0000-0000-000000000002","key":"user-management:activateUser","description":"Activate user accounts"}
+{"id":"00000000-0000-0000-0000-000000000003","key":"user-management:deactivateUser","description":"Deactivate user accounts"}
+{"id":"00000000-0000-0000-0000-000000000004","key":"user-management:reactivateUser","description":"Reactivate user accounts"}
+{"id":"00000000-0000-0000-0000-000000000005","key":"user-management:createRole","description":"Create roles"}
+{"id":"00000000-0000-0000-0000-000000000006","key":"user-management:assignPermissionToRole","description":"Assign permissions to roles"}
+{"id":"00000000-0000-0000-0000-000000000007","key":"user-management:revokePermissionFromRole","description":"Revoke permissions from roles"}
+{"id":"00000000-0000-0000-0000-000000000008","key":"user-management:assignRoleToUser","description":"Assign roles to users"}
+{"id":"00000000-0000-0000-0000-000000000009","key":"user-management:revokeRoleFromUser","description":"Revoke roles from users"}
+{"id":"00000000-0000-0000-0000-00000000000a","key":"user-management:createPermission","description":"Create permissions"}
+{"id":"00000000-0000-0000-0000-00000000000b","key":"audit:logAuditEvent","description":"Log audit events"}
+{"id":"00000000-0000-0000-0000-00000000000c","key":"user-management:updateUser","description":"Update user profiles"}
+{"id":"00000000-0000-0000-0000-00000000000d","key":"user-management:updateOwnProfile","description":"Update own profile"}

package/templates/scaffold/app/backend/seed/data/Permission.schema.ts

@@ -1,7 +1,7 @@
 import { t } from "@tailor-platform/sdk";
 import { defineSchema } from "@tailor-platform/sdk/seed";
 import { createTailorDBHook, createStandardSchema } from "@tailor-platform/sdk/test";
-import { permission } from "../../src/modules";
+import { permission } from "../../src/modules-db";
 
 const schemaType = t.object({
   ...permission.pickFields(["id","createdAt"], { optional: true }),

package/templates/scaffold/app/backend/seed/data/PolicyFieldRule.schema.ts

@@ -0,0 +1,20 @@
+import { t } from "@tailor-platform/sdk";
+import { defineSchema } from "@tailor-platform/sdk/seed";
+import { createTailorDBHook, createStandardSchema } from "@tailor-platform/sdk/test";
+import { policyFieldRule } from "../../src/modules-db";
+
+const schemaType = t.object({
+  ...policyFieldRule.pickFields(["id","createdAt"], { optional: true }),
+  ...policyFieldRule.omitFields(["id","createdAt"]),
+});
+
+const hook = createTailorDBHook(policyFieldRule);
+
+export const schema = defineSchema(
+  createStandardSchema(schemaType, hook),
+  {
+    foreignKeys: [
+      {"column":"auditPolicyId","references":{"table":"AuditPolicy","column":"id"}},
+    ],
+  }
+);

package/templates/scaffold/app/backend/seed/data/Role.jsonl

@@ -0,0 +1 @@
+{"id":"00000000-0000-0000-0001-000000000001","name":"Admin","description":"Full system access"}

package/templates/scaffold/app/backend/seed/data/Role.schema.ts

@@ -1,7 +1,7 @@
 import { t } from "@tailor-platform/sdk";
 import { defineSchema } from "@tailor-platform/sdk/seed";
 import { createTailorDBHook, createStandardSchema } from "@tailor-platform/sdk/test";
-import { role } from "../../src/modules";
+import { role } from "../../src/modules-db";
 
 const schemaType = t.object({
   ...role.pickFields(["id","createdAt"], { optional: true }),