@plures/praxis 0.2.1 → 1.0.1

package/src/__tests__/state-docs-integration.test.ts

@@ -0,0 +1,297 @@
+/**
+ * State-Docs Integration Tests
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  createStateDocsGenerator,
+  generateDocs,
+  StateDocsGenerator,
+} from "../integrations/state-docs.js";
+import type { PraxisSchema } from "../core/schema/types.js";
+
+describe("State-Docs Integration", () => {
+  const testSchema: PraxisSchema = {
+    version: "1.0.0",
+    name: "TestProject",
+    description: "A test project for documentation generation",
+    models: [
+      {
+        name: "User",
+        description: "User model",
+        fields: [
+          { name: "id", type: "string", description: "User ID" },
+          { name: "name", type: "string", description: "User name" },
+          { name: "email", type: "string", description: "Email address", optional: true },
+        ],
+      },
+      {
+        name: "Post",
+        description: "Blog post model",
+        fields: [
+          { name: "id", type: "string" },
+          { name: "title", type: "string" },
+          { name: "content", type: "string" },
+          { name: "authorId", type: "string" },
+        ],
+      },
+    ],
+    components: [
+      {
+        name: "UserProfile",
+        type: "display",
+        description: "User profile display component",
+        model: "User",
+      },
+      {
+        name: "PostEditor",
+        type: "form",
+        description: "Post editing form",
+        model: "Post",
+      },
+    ],
+    logic: [
+      {
+        id: "auth-logic",
+        description: "Authentication logic module",
+        events: [
+          { tag: "Login", payload: { username: "string", password: "string" }, description: "User login event" },
+          { tag: "Logout", payload: { userId: "string" }, description: "User logout event" },
+        ],
+        facts: [
+          { tag: "UserLoggedIn", payload: { userId: "string", timestamp: "number" }, description: "User is logged in" },
+        ],
+        rules: [
+          { id: "process-login", description: "Process login request", then: "validateCredentials()" },
+        ],
+        constraints: [
+          { id: "valid-session", description: "Session must be valid", check: "session.isValid()", message: "Invalid session" },
+        ],
+      },
+    ],
+  };
+
+  describe("createStateDocsGenerator", () => {
+    it("should create a generator with default config", () => {
+      const generator = createStateDocsGenerator({
+        projectTitle: "Test Project",
+      });
+      
+      expect(generator).toBeInstanceOf(StateDocsGenerator);
+    });
+    
+    it("should create a generator with custom config", () => {
+      const generator = createStateDocsGenerator({
+        projectTitle: "Test Project",
+        target: "./custom-docs",
+        visualization: {
+          format: "mermaid",
+          theme: "dark",
+        },
+        template: {
+          toc: true,
+          timestamp: false,
+        },
+      });
+      
+      expect(generator).toBeInstanceOf(StateDocsGenerator);
+    });
+  });
+
+  describe("generateFromSchema", () => {
+    it("should generate documentation from schema", () => {
+      const generator = createStateDocsGenerator({
+        projectTitle: "Test Project",
+      });
+      
+      const docs = generator.generateFromSchema(testSchema);
+      
+      expect(docs).toBeDefined();
+      expect(docs.length).toBeGreaterThan(0);
+    });
+    
+    it("should generate README", () => {
+      const generator = createStateDocsGenerator({
+        projectTitle: "Test Project",
+      });
+      
+      const docs = generator.generateFromSchema(testSchema);
+      const readme = docs.find(d => d.path.endsWith("README.md"));
+      
+      expect(readme).toBeDefined();
+      expect(readme?.type).toBe("markdown");
+      expect(readme?.content).toContain("TestProject");
+    });
+    
+    it("should generate models documentation", () => {
+      const generator = createStateDocsGenerator({
+        projectTitle: "Test Project",
+      });
+      
+      const docs = generator.generateFromSchema(testSchema);
+      const modelsDocs = docs.find(d => d.path.endsWith("models.md"));
+      
+      expect(modelsDocs).toBeDefined();
+      expect(modelsDocs?.content).toContain("User");
+      expect(modelsDocs?.content).toContain("Post");
+    });
+    
+    it("should generate components documentation", () => {
+      const generator = createStateDocsGenerator({
+        projectTitle: "Test Project",
+      });
+      
+      const docs = generator.generateFromSchema(testSchema);
+      const componentsDocs = docs.find(d => d.path.endsWith("components.md"));
+      
+      expect(componentsDocs).toBeDefined();
+      expect(componentsDocs?.content).toContain("UserProfile");
+      expect(componentsDocs?.content).toContain("PostEditor");
+    });
+    
+    it("should generate logic documentation", () => {
+      const generator = createStateDocsGenerator({
+        projectTitle: "Test Project",
+      });
+      
+      const docs = generator.generateFromSchema(testSchema);
+      const logicDocs = docs.find(d => d.path.includes("auth-logic.md"));
+      
+      expect(logicDocs).toBeDefined();
+      expect(logicDocs?.content).toContain("Login");
+      expect(logicDocs?.content).toContain("Logout");
+    });
+    
+    it("should generate Mermaid diagrams", () => {
+      const generator = createStateDocsGenerator({
+        projectTitle: "Test Project",
+      });
+      
+      const docs = generator.generateFromSchema(testSchema);
+      const mermaidDocs = docs.filter(d => d.type === "mermaid");
+      
+      expect(mermaidDocs.length).toBeGreaterThan(0);
+      expect(mermaidDocs[0].content).toContain("stateDiagram-v2");
+    });
+    
+    it("should include table of contents when enabled", () => {
+      const generator = createStateDocsGenerator({
+        projectTitle: "Test Project",
+        template: { toc: true },
+      });
+      
+      const docs = generator.generateFromSchema(testSchema);
+      const readme = docs.find(d => d.path.endsWith("README.md"));
+      
+      expect(readme?.content).toContain("Table of Contents");
+    });
+    
+    it("should include timestamp when enabled", () => {
+      const generator = createStateDocsGenerator({
+        projectTitle: "Test Project",
+        template: { timestamp: true },
+      });
+      
+      const docs = generator.generateFromSchema(testSchema);
+      const readme = docs.find(d => d.path.endsWith("README.md"));
+      
+      expect(readme?.content).toContain("Generated on");
+    });
+    
+    it("should include statistics", () => {
+      const generator = createStateDocsGenerator({
+        projectTitle: "Test Project",
+      });
+      
+      const docs = generator.generateFromSchema(testSchema);
+      const readme = docs.find(d => d.path.endsWith("README.md"));
+      
+      expect(readme?.content).toContain("Statistics");
+      expect(readme?.content).toContain("Models");
+      expect(readme?.content).toContain("Components");
+    });
+  });
+
+  describe("generateDocs (convenience function)", () => {
+    it("should generate docs directly from schema", () => {
+      const docs = generateDocs(testSchema, {
+        projectTitle: "Quick Project",
+      });
+      
+      expect(docs).toBeDefined();
+      expect(docs.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe("generateFromModule", () => {
+    it("should generate documentation from a Praxis module", () => {
+      const generator = createStateDocsGenerator({
+        projectTitle: "Test Project",
+      });
+      
+      const docs = generator.generateFromModule({
+        rules: [
+          {
+            id: "test-rule",
+            description: "A test rule",
+            impl: () => [],
+          },
+        ],
+        constraints: [
+          {
+            id: "test-constraint",
+            description: "A test constraint",
+            impl: () => true,
+          },
+        ],
+      });
+      
+      expect(docs.length).toBe(3); // rules.md, constraints.md, state-diagram.mmd
+    });
+    
+    it("should generate rules documentation from module", () => {
+      const generator = createStateDocsGenerator({
+        projectTitle: "Test Project",
+      });
+      
+      const docs = generator.generateFromModule({
+        rules: [
+          {
+            id: "auth.login",
+            description: "Process user login",
+            impl: () => [],
+          },
+        ],
+        constraints: [],
+      });
+      
+      const rulesDocs = docs.find(d => d.path.endsWith("rules.md"));
+      expect(rulesDocs).toBeDefined();
+      expect(rulesDocs?.content).toContain("auth.login");
+      expect(rulesDocs?.content).toContain("Process user login");
+    });
+    
+    it("should generate constraints documentation from module", () => {
+      const generator = createStateDocsGenerator({
+        projectTitle: "Test Project",
+      });
+      
+      const docs = generator.generateFromModule({
+        rules: [],
+        constraints: [
+          {
+            id: "user.valid",
+            description: "User must be valid",
+            impl: () => true,
+            meta: { errorMessage: "User is invalid" },
+          },
+        ],
+      });
+      
+      const constraintsDocs = docs.find(d => d.path.endsWith("constraints.md"));
+      expect(constraintsDocs).toBeDefined();
+      expect(constraintsDocs?.content).toContain("user.valid");
+      expect(constraintsDocs?.content).toContain("User must be valid");
+    });
+  });
+});

package/src/__tests__/tauri-integration.test.ts

@@ -0,0 +1,298 @@
+/**
+ * Tauri Integration Tests
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  createMockTauriBridge,
+  createTauriPraxisAdapter,
+  attachTauriToEngine,
+  generateTauriConfig,
+} from "../integrations/tauri.js";
+import { createPraxisEngine, PraxisRegistry } from "../index.js";
+
+describe("Tauri Integration", () => {
+  describe("createMockTauriBridge", () => {
+    it("should create a mock bridge", () => {
+      const bridge = createMockTauriBridge();
+      
+      expect(bridge).toBeDefined();
+      expect(bridge.app.name).toBe("Mock App");
+      expect(bridge.app.tauriVersion).toBe("mock");
+    });
+    
+    it("should provide file system operations", async () => {
+      const bridge = createMockTauriBridge();
+      
+      // Write and read text file
+      await bridge.fs.writeTextFile("/test.txt", "Hello, World!");
+      const content = await bridge.fs.readTextFile("/test.txt");
+      
+      expect(content).toBe("Hello, World!");
+    });
+    
+    it("should check file existence", async () => {
+      const bridge = createMockTauriBridge();
+      
+      await bridge.fs.writeTextFile("/exists.txt", "content");
+      
+      expect(await bridge.fs.exists("/exists.txt")).toBe(true);
+      expect(await bridge.fs.exists("/not-exists.txt")).toBe(false);
+    });
+    
+    it("should remove files", async () => {
+      const bridge = createMockTauriBridge();
+      
+      await bridge.fs.writeTextFile("/to-remove.txt", "content");
+      expect(await bridge.fs.exists("/to-remove.txt")).toBe(true);
+      
+      await bridge.fs.remove("/to-remove.txt");
+      expect(await bridge.fs.exists("/to-remove.txt")).toBe(false);
+    });
+    
+    it("should rename files", async () => {
+      const bridge = createMockTauriBridge();
+      
+      await bridge.fs.writeTextFile("/old.txt", "content");
+      await bridge.fs.rename("/old.txt", "/new.txt");
+      
+      expect(await bridge.fs.exists("/old.txt")).toBe(false);
+      expect(await bridge.fs.exists("/new.txt")).toBe(true);
+      expect(await bridge.fs.readTextFile("/new.txt")).toBe("content");
+    });
+    
+    it("should handle binary files", async () => {
+      const bridge = createMockTauriBridge();
+      const data = new Uint8Array([1, 2, 3, 4, 5]);
+      
+      await bridge.fs.writeFile("/binary.bin", data);
+      const read = await bridge.fs.readFile("/binary.bin");
+      
+      expect(read).toEqual(data);
+    });
+    
+    it("should invoke commands", async () => {
+      const bridge = createMockTauriBridge();
+      const result = await bridge.invoke("test-command", { arg: "value" });
+      
+      expect(result).toBeNull(); // Mock returns null
+    });
+    
+    it("should emit and listen to events", async () => {
+      const bridge = createMockTauriBridge();
+      
+      const received: unknown[] = [];
+      await bridge.listen("test-event", (event) => {
+        received.push(event.payload);
+      });
+      
+      await bridge.emit("test-event", { data: "test" });
+      
+      expect(received.length).toBe(1);
+      expect(received[0]).toEqual({ data: "test" });
+    });
+    
+    it("should provide notification API", async () => {
+      const bridge = createMockTauriBridge();
+      
+      const permission = await bridge.notification.checkPermission();
+      expect(permission).toBe("granted");
+      
+      // Should not throw
+      await bridge.notification.send({ title: "Test", body: "Body" });
+    });
+    
+    it("should check for updates", async () => {
+      const bridge = createMockTauriBridge();
+      
+      const update = await bridge.checkForUpdates();
+      expect(update).toBeNull(); // Mock returns null
+    });
+  });
+
+  describe("createTauriPraxisAdapter", () => {
+    it("should create an adapter", () => {
+      const bridge = createMockTauriBridge();
+      const adapter = createTauriPraxisAdapter({ bridge });
+      
+      expect(adapter).toBeDefined();
+      expect(adapter.getStatePath()).toBe("praxis-state.json");
+      expect(adapter.getEventsPath()).toBe("praxis-events.json");
+    });
+    
+    it("should use custom paths", () => {
+      const bridge = createMockTauriBridge();
+      const adapter = createTauriPraxisAdapter({
+        bridge,
+        statePath: "custom-state.json",
+        eventsPath: "custom-events.json",
+      });
+      
+      expect(adapter.getStatePath()).toBe("custom-state.json");
+      expect(adapter.getEventsPath()).toBe("custom-events.json");
+    });
+    
+    it("should save and load state", async () => {
+      const bridge = createMockTauriBridge();
+      const adapter = createTauriPraxisAdapter<{ count: number }>({ bridge });
+      
+      await adapter.saveState({ count: 42 });
+      const loaded = await adapter.loadState();
+      
+      expect(loaded).toEqual({ count: 42 });
+    });
+    
+    it("should return null for missing state", async () => {
+      const bridge = createMockTauriBridge();
+      const adapter = createTauriPraxisAdapter<{ count: number }>({ bridge });
+      
+      const loaded = await adapter.loadState();
+      expect(loaded).toBeNull();
+    });
+    
+    it("should save and load events", async () => {
+      const bridge = createMockTauriBridge();
+      const adapter = createTauriPraxisAdapter({ bridge });
+      
+      const events = [
+        { tag: "Event1", payload: { id: "1" } },
+        { tag: "Event2", payload: { id: "2" } },
+      ];
+      
+      await adapter.saveEvents(events);
+      const loaded = await adapter.loadEvents();
+      
+      expect(loaded).toEqual(events);
+    });
+    
+    it("should return empty array for missing events", async () => {
+      const bridge = createMockTauriBridge();
+      const adapter = createTauriPraxisAdapter({ bridge });
+      
+      const loaded = await adapter.loadEvents();
+      expect(loaded).toEqual([]);
+    });
+    
+    it("should provide watch function", async () => {
+      const bridge = createMockTauriBridge();
+      const adapter = createTauriPraxisAdapter<{ count: number }>({ bridge });
+      
+      const cleanup = await adapter.watchStateFile(() => {});
+      expect(cleanup).toBeInstanceOf(Function);
+      cleanup();
+    });
+  });
+
+  describe("attachTauriToEngine", () => {
+    it("should attach adapter to engine", () => {
+      const bridge = createMockTauriBridge();
+      const adapter = createTauriPraxisAdapter({ bridge });
+      const registry = new PraxisRegistry();
+      const engine = createPraxisEngine({
+        initialContext: { count: 0 },
+        registry,
+      });
+      
+      const cleanup = attachTauriToEngine(engine, adapter, {
+        autoSave: true,
+        saveInterval: 1000,
+      });
+      
+      expect(cleanup).toBeInstanceOf(Function);
+      cleanup();
+    });
+    
+    it("should work without auto-save", () => {
+      const bridge = createMockTauriBridge();
+      const adapter = createTauriPraxisAdapter({ bridge });
+      const registry = new PraxisRegistry();
+      const engine = createPraxisEngine({
+        initialContext: {},
+        registry,
+      });
+      
+      const cleanup = attachTauriToEngine(engine, adapter, {
+        autoSave: false,
+      });
+      
+      expect(cleanup).toBeInstanceOf(Function);
+      cleanup();
+    });
+  });
+
+  describe("generateTauriConfig", () => {
+    it("should generate basic config", () => {
+      const config = generateTauriConfig({
+        name: "My App",
+        version: "1.0.0",
+        identifier: "com.example.myapp",
+      });
+      
+      expect(config.productName).toBe("My App");
+      expect(config.version).toBe("1.0.0");
+      expect(config.identifier).toBe("com.example.myapp");
+    });
+    
+    it("should include window config", () => {
+      const config = generateTauriConfig({
+        name: "My App",
+        version: "1.0.0",
+        identifier: "com.example.myapp",
+        window: {
+          title: "My Window",
+          width: 1024,
+          height: 768,
+          resizable: true,
+          center: true,
+        },
+      });
+      
+      const app = config.app as { windows: Array<{ title: string; width: number; height: number }> };
+      expect(app.windows[0].title).toBe("My Window");
+      expect(app.windows[0].width).toBe(1024);
+      expect(app.windows[0].height).toBe(768);
+    });
+    
+    it("should include security config", () => {
+      const config = generateTauriConfig({
+        name: "My App",
+        version: "1.0.0",
+        identifier: "com.example.myapp",
+        security: {
+          csp: "default-src 'self'; script-src 'self'",
+          devTools: true,
+        },
+      });
+      
+      const app = config.app as { security: { csp: string; devtools: boolean } };
+      expect(app.security.csp).toBe("default-src 'self'; script-src 'self'");
+      expect(app.security.devtools).toBe(true);
+    });
+    
+    it("should include plugins", () => {
+      const config = generateTauriConfig({
+        name: "My App",
+        version: "1.0.0",
+        identifier: "com.example.myapp",
+        plugins: [
+          { name: "shell", config: { open: true } },
+          { name: "fs", config: { scope: ["$APP/*"] } },
+        ],
+      });
+      
+      const plugins = config.plugins as Record<string, unknown>;
+      expect(plugins.shell).toEqual({ open: true });
+      expect(plugins.fs).toEqual({ scope: ["$APP/*"] });
+    });
+    
+    it("should have $schema", () => {
+      const config = generateTauriConfig({
+        name: "My App",
+        version: "1.0.0",
+        identifier: "com.example.myapp",
+      });
+      
+      expect(config.$schema).toContain("tauri-config-schema");
+    });
+  });
+});

package/src/__tests__/terminal-node.test.ts

@@ -290,7 +290,7 @@ orchestration:
       
       expect(result).toBeDefined();
       expect(result.command).toBe('echo hello');
-      expect(result.output).toContain('echo hello');
+      expect(result.output).toContain('hello');
       expect(result.exitCode).toBe(0);
       expect(result.timestamp).toBeGreaterThan(0);