@plures/praxis 0.2.0

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "@plures/praxis",
+  "version": "0.2.0",
+  "description": "The Full Plures Application Framework - declarative schemas, logic engine, component generation, and local-first data",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "praxis": "./dist/cli/index.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./svelte": {
+      "types": "./dist/integrations/svelte.d.ts",
+      "default": "./dist/integrations/svelte.js"
+    },
+    "./schema": {
+      "types": "./dist/core/schema/types.d.ts",
+      "default": "./dist/core/schema/types.js"
+    },
+    "./component": {
+      "types": "./dist/core/component/generator.d.ts",
+      "default": "./dist/core/component/generator.js"
+    },
+    "./cloud": {
+      "types": "./dist/cloud/index.d.ts",
+      "default": "./dist/cloud/index.js"
+    },
+    "./components": {
+      "types": "./dist/components/index.d.ts",
+      "svelte": "./src/components/TerminalNode.svelte"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "core",
+    "cli",
+    "templates",
+    "docs",
+    "README.md",
+    "FRAMEWORK.md",
+    "src/components"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "typecheck": "tsc --noEmit",
+    "cli": "node ./dist/cli/index.js"
+  },
+  "keywords": [
+    "praxis",
+    "framework",
+    "plures",
+    "logic",
+    "schema",
+    "component-generation",
+    "local-first",
+    "functional",
+    "typescript",
+    "state-management",
+    "facts",
+    "rules",
+    "constraints",
+    "orchestration",
+    "canvas",
+    "visual-development"
+  ],
+  "author": "Plures",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^24.10.1",
+    "@vitest/ui": "^4.0.10",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.10"
+  },
+  "dependencies": {
+    "commander": "^14.0.2",
+    "js-yaml": "^4.1.1"
+  },
+  "peerDependencies": {
+    "svelte": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "svelte": {
+      "optional": true
+    }
+  }
+}

package/src/__tests__/actors.test.ts

@@ -0,0 +1,270 @@
+/**
+ * Actor system tests
+ */
+
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { ActorManager, createTimerActor, type Actor } from "../core/actors.js";
+import { createPraxisEngine } from "../core/engine.js";
+import { PraxisRegistry } from "../core/rules.js";
+import { defineEvent, defineRule, defineFact } from "../dsl/index.js";
+
+describe("Actor System", () => {
+  describe("ActorManager", () => {
+    let manager: ActorManager<{ count: number }>;
+    let registry: PraxisRegistry<{ count: number }>;
+    let engine: ReturnType<typeof createPraxisEngine<{ count: number }>>;
+
+    beforeEach(() => {
+      manager = new ActorManager();
+      registry = new PraxisRegistry();
+      engine = createPraxisEngine({
+        initialContext: { count: 0 },
+        registry,
+      });
+      manager.attachEngine(engine);
+    });
+
+    it("should register and start an actor", async () => {
+      const onStartSpy = vi.fn();
+      const actor: Actor<{ count: number }> = {
+        id: "test-actor",
+        description: "Test actor",
+        onStart: onStartSpy,
+      };
+
+      manager.register(actor);
+      await manager.start("test-actor");
+
+      expect(onStartSpy).toHaveBeenCalledWith(engine);
+      expect(manager.isActive("test-actor")).toBe(true);
+    });
+
+    it("should throw when registering duplicate actor IDs", () => {
+      const actor: Actor<{ count: number }> = {
+        id: "duplicate",
+        description: "Test actor",
+      };
+
+      manager.register(actor);
+      expect(() => manager.register(actor)).toThrow('Actor with id "duplicate" already registered');
+    });
+
+    it("should throw when starting already active actor", async () => {
+      const actor: Actor<{ count: number }> = {
+        id: "test",
+        description: "Test",
+      };
+
+      manager.register(actor);
+      await manager.start("test");
+      await expect(manager.start("test")).rejects.toThrow('Actor "test" is already started');
+    });
+
+    it("should stop an actor", async () => {
+      const onStopSpy = vi.fn();
+      const actor: Actor<{ count: number }> = {
+        id: "test-actor",
+        description: "Test actor",
+        onStop: onStopSpy,
+      };
+
+      manager.register(actor);
+      await manager.start("test-actor");
+      await manager.stop("test-actor");
+
+      expect(onStopSpy).toHaveBeenCalled();
+      expect(manager.isActive("test-actor")).toBe(false);
+    });
+
+    it("should notify actors of state changes", async () => {
+      const onStateChangeSpy = vi.fn();
+      const actor: Actor<{ count: number }> = {
+        id: "observer",
+        description: "Observer actor",
+        onStateChange: onStateChangeSpy,
+      };
+
+      manager.register(actor);
+      await manager.start("observer");
+
+      const state = engine.getState();
+      await manager.notifyStateChange(state);
+
+      expect(onStateChangeSpy).toHaveBeenCalledWith(state, engine);
+    });
+
+    it("should start all registered actors", async () => {
+      const onStart1 = vi.fn();
+      const onStart2 = vi.fn();
+
+      manager.register({ id: "actor1", description: "Actor 1", onStart: onStart1 });
+      manager.register({ id: "actor2", description: "Actor 2", onStart: onStart2 });
+
+      await manager.startAll();
+
+      expect(onStart1).toHaveBeenCalled();
+      expect(onStart2).toHaveBeenCalled();
+      expect(manager.getActiveActorIds()).toHaveLength(2);
+    });
+
+    it("should stop all active actors", async () => {
+      const onStop1 = vi.fn();
+      const onStop2 = vi.fn();
+
+      manager.register({ id: "actor1", description: "Actor 1", onStop: onStop1 });
+      manager.register({ id: "actor2", description: "Actor 2", onStop: onStop2 });
+
+      await manager.startAll();
+      await manager.stopAll();
+
+      expect(onStop1).toHaveBeenCalled();
+      expect(onStop2).toHaveBeenCalled();
+      expect(manager.getActiveActorIds()).toHaveLength(0);
+    });
+
+    it("should handle async actor methods", async () => {
+      let startResolved = false;
+      let stopResolved = false;
+
+      const actor: Actor<{ count: number }> = {
+        id: "async-actor",
+        description: "Async actor",
+        onStart: async () => {
+          await new Promise((resolve) => setTimeout(resolve, 10));
+          startResolved = true;
+        },
+        onStop: async () => {
+          await new Promise((resolve) => setTimeout(resolve, 10));
+          stopResolved = true;
+        },
+      };
+
+      manager.register(actor);
+      await manager.start("async-actor");
+      expect(startResolved).toBe(true);
+
+      await manager.stop("async-actor");
+      expect(stopResolved).toBe(true);
+    });
+
+    it("should not notify stopped actors of state changes", async () => {
+      const onStateChangeSpy = vi.fn();
+      const actor: Actor<{ count: number }> = {
+        id: "observer",
+        description: "Observer",
+        onStateChange: onStateChangeSpy,
+      };
+
+      manager.register(actor);
+      await manager.start("observer");
+      await manager.stop("observer");
+
+      const state = engine.getState();
+      await manager.notifyStateChange(state);
+
+      expect(onStateChangeSpy).not.toHaveBeenCalled();
+    });
+
+    it("should throw when starting actor without attached engine", async () => {
+      const actor: Actor<{ count: number }> = {
+        id: "test",
+        description: "Test",
+      };
+
+      const newManager = new ActorManager<{ count: number }>();
+      newManager.register(actor);
+
+      await expect(newManager.start("test")).rejects.toThrow(
+        "Actor manager not attached to an engine"
+      );
+    });
+  });
+
+  describe("createTimerActor", () => {
+    it("should create a timer actor that dispatches events", async () => {
+      vi.useFakeTimers();
+
+      const Tick = defineEvent<"TICK", {}>("TICK");
+      const TickReceived = defineFact<"TickReceived", {}>("TickReceived");
+
+      const tickRule = defineRule<{ count: number }>({
+        id: "tick.rule",
+        description: "Count ticks",
+        impl: (state, events) => {
+          if (events.some(Tick.is)) {
+            state.context.count += 1;
+            return [TickReceived.create({})];
+          }
+          return [];
+        },
+      });
+
+      const registry = new PraxisRegistry<{ count: number }>();
+      registry.registerRule(tickRule);
+
+      const engine = createPraxisEngine({
+        initialContext: { count: 0 },
+        registry,
+      });
+
+      const manager = new ActorManager<{ count: number }>();
+      manager.attachEngine(engine);
+
+      const timerActor = createTimerActor("timer", 100, () => Tick.create({}));
+      manager.register(timerActor);
+      await manager.start("timer");
+
+      // Advance timers
+      vi.advanceTimersByTime(250);
+
+      // Should have ticked at least twice (at 100ms and 200ms)
+      expect(engine.getContext().count).toBeGreaterThanOrEqual(2);
+
+      await manager.stop("timer");
+      vi.useRealTimers();
+    });
+
+    it("should stop dispatching events after actor is stopped", async () => {
+      vi.useFakeTimers();
+
+      const Tick = defineEvent<"TICK", {}>("TICK");
+      const registry = new PraxisRegistry<{ count: number }>();
+
+      const tickRule = defineRule<{ count: number }>({
+        id: "tick.rule",
+        description: "Count ticks",
+        impl: (state, events) => {
+          if (events.some(Tick.is)) {
+            state.context.count += 1;
+          }
+          return [];
+        },
+      });
+      registry.registerRule(tickRule);
+
+      const engine = createPraxisEngine({
+        initialContext: { count: 0 },
+        registry,
+      });
+
+      const manager = new ActorManager<{ count: number }>();
+      manager.attachEngine(engine);
+
+      const timerActor = createTimerActor("timer", 50, () => Tick.create({}));
+      manager.register(timerActor);
+      await manager.start("timer");
+
+      vi.advanceTimersByTime(100);
+      const countBeforeStop = engine.getContext().count;
+
+      await manager.stop("timer");
+      vi.advanceTimersByTime(200);
+      const countAfterStop = engine.getContext().count;
+
+      // Count should not increase after stopping
+      expect(countAfterStop).toBe(countBeforeStop);
+
+      vi.useRealTimers();
+    });
+  });
+});

package/src/__tests__/billing.test.ts

@@ -0,0 +1,175 @@
+/**
+ * Billing Tests
+ * 
+ * Tests for billing types and utilities.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  SubscriptionTier,
+  SubscriptionStatus,
+  BillingProvider,
+  TIER_LIMITS,
+  hasAccessToTier,
+  checkUsageLimits,
+  createFreeSubscription,
+  createSponsorSubscription,
+} from "../cloud/billing.js";
+
+describe("Billing", () => {
+  describe("Tier Limits", () => {
+    it("should have limits for all tiers", () => {
+      expect(TIER_LIMITS[SubscriptionTier.FREE]).toBeDefined();
+      expect(TIER_LIMITS[SubscriptionTier.SOLO]).toBeDefined();
+      expect(TIER_LIMITS[SubscriptionTier.TEAM]).toBeDefined();
+      expect(TIER_LIMITS[SubscriptionTier.ENTERPRISE]).toBeDefined();
+    });
+
+    it("should have increasing limits for higher tiers", () => {
+      expect(TIER_LIMITS[SubscriptionTier.SOLO].maxSyncsPerMonth).toBeGreaterThan(
+        TIER_LIMITS[SubscriptionTier.FREE].maxSyncsPerMonth
+      );
+      expect(TIER_LIMITS[SubscriptionTier.TEAM].maxSyncsPerMonth).toBeGreaterThan(
+        TIER_LIMITS[SubscriptionTier.SOLO].maxSyncsPerMonth
+      );
+      expect(TIER_LIMITS[SubscriptionTier.ENTERPRISE].maxSyncsPerMonth).toBeGreaterThan(
+        TIER_LIMITS[SubscriptionTier.TEAM].maxSyncsPerMonth
+      );
+    });
+  });
+
+  describe("hasAccessToTier", () => {
+    it("should grant access to same tier", () => {
+      const subscription = createFreeSubscription();
+      expect(hasAccessToTier(subscription, SubscriptionTier.FREE)).toBe(true);
+    });
+
+    it("should grant access to lower tiers", () => {
+      const subscription = {
+        ...createFreeSubscription(),
+        tier: SubscriptionTier.ENTERPRISE,
+      };
+      expect(hasAccessToTier(subscription, SubscriptionTier.FREE)).toBe(true);
+      expect(hasAccessToTier(subscription, SubscriptionTier.SOLO)).toBe(true);
+      expect(hasAccessToTier(subscription, SubscriptionTier.TEAM)).toBe(true);
+    });
+
+    it("should deny access to higher tiers", () => {
+      const subscription = createFreeSubscription();
+      expect(hasAccessToTier(subscription, SubscriptionTier.SOLO)).toBe(false);
+      expect(hasAccessToTier(subscription, SubscriptionTier.TEAM)).toBe(false);
+      expect(hasAccessToTier(subscription, SubscriptionTier.ENTERPRISE)).toBe(false);
+    });
+
+    it("should deny access if subscription is not active", () => {
+      const subscription = {
+        ...createFreeSubscription(),
+        status: SubscriptionStatus.EXPIRED,
+      };
+      expect(hasAccessToTier(subscription, SubscriptionTier.FREE)).toBe(false);
+    });
+  });
+
+  describe("checkUsageLimits", () => {
+    it("should pass when usage is within limits", () => {
+      const subscription = createFreeSubscription();
+      const result = checkUsageLimits(subscription, {
+        syncCount: 500,
+        storageBytes: 5 * 1024 * 1024, // 5 MB
+        teamMembers: 1,
+        appCount: 1,
+      });
+      expect(result.withinLimits).toBe(true);
+      expect(result.violations).toHaveLength(0);
+    });
+
+    it("should fail when sync count exceeds limit", () => {
+      const subscription = createFreeSubscription();
+      const result = checkUsageLimits(subscription, {
+        syncCount: 2000,
+        storageBytes: 0,
+        teamMembers: 1,
+        appCount: 1,
+      });
+      expect(result.withinLimits).toBe(false);
+      expect(result.violations.length).toBeGreaterThan(0);
+      expect(result.violations[0]).toContain("Sync limit exceeded");
+    });
+
+    it("should fail when storage exceeds limit", () => {
+      const subscription = createFreeSubscription();
+      const result = checkUsageLimits(subscription, {
+        syncCount: 0,
+        storageBytes: 20 * 1024 * 1024, // 20 MB
+        teamMembers: 1,
+        appCount: 1,
+      });
+      expect(result.withinLimits).toBe(false);
+      expect(result.violations.length).toBeGreaterThan(0);
+      expect(result.violations[0]).toContain("Storage limit exceeded");
+    });
+
+    it("should fail when team members exceed limit", () => {
+      const subscription = createFreeSubscription();
+      const result = checkUsageLimits(subscription, {
+        syncCount: 0,
+        storageBytes: 0,
+        teamMembers: 5,
+        appCount: 1,
+      });
+      expect(result.withinLimits).toBe(false);
+      expect(result.violations.length).toBeGreaterThan(0);
+      expect(result.violations[0]).toContain("Team member limit exceeded");
+    });
+
+    it("should allow unlimited team members for enterprise", () => {
+      const subscription = {
+        ...createFreeSubscription(),
+        tier: SubscriptionTier.ENTERPRISE,
+        limits: TIER_LIMITS[SubscriptionTier.ENTERPRISE],
+      };
+      const result = checkUsageLimits(subscription, {
+        syncCount: 0,
+        storageBytes: 0,
+        teamMembers: 1000,
+        appCount: 1,
+      });
+      expect(result.withinLimits).toBe(true);
+    });
+  });
+
+  describe("createFreeSubscription", () => {
+    it("should create a free subscription", () => {
+      const subscription = createFreeSubscription();
+      expect(subscription.tier).toBe(SubscriptionTier.FREE);
+      expect(subscription.status).toBe(SubscriptionStatus.ACTIVE);
+      expect(subscription.provider).toBe(BillingProvider.NONE);
+      expect(subscription.autoRenew).toBe(true);
+    });
+  });
+
+  describe("createSponsorSubscription", () => {
+    it("should create solo tier for $5/month", () => {
+      const subscription = createSponsorSubscription("Solo", 500);
+      expect(subscription.tier).toBe(SubscriptionTier.SOLO);
+      expect(subscription.provider).toBe(BillingProvider.SPONSORS);
+    });
+
+    it("should create team tier for $20/month", () => {
+      const subscription = createSponsorSubscription("Team", 2000);
+      expect(subscription.tier).toBe(SubscriptionTier.TEAM);
+      expect(subscription.provider).toBe(BillingProvider.SPONSORS);
+    });
+
+    it("should create enterprise tier for $50/month", () => {
+      const subscription = createSponsorSubscription("Enterprise", 5000);
+      expect(subscription.tier).toBe(SubscriptionTier.ENTERPRISE);
+      expect(subscription.provider).toBe(BillingProvider.SPONSORS);
+    });
+
+    it("should default to free tier for low amounts", () => {
+      const subscription = createSponsorSubscription("Supporter", 100);
+      expect(subscription.tier).toBe(SubscriptionTier.FREE);
+    });
+  });
+});