@plures/praxis 1.0.3 → 1.1.1

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

@@ -2,129 +2,129 @@
  * Unum Integration Tests
  */
 
-import { describe, it, expect, beforeEach } from "vitest";
-import { createUnumAdapter, attachUnumToEngine } from "../integrations/unum.js";
-import { createInMemoryDB } from "../integrations/pluresdb.js";
-import { createPraxisEngine, PraxisRegistry } from "../index.js";
-
-describe("Unum Integration", () => {
-  describe("createUnumAdapter", () => {
-    it("should create an adapter without identity", async () => {
+import { describe, it, expect, beforeEach } from 'vitest';
+import { createUnumAdapter, attachUnumToEngine } from '../integrations/unum.js';
+import { createInMemoryDB } from '../integrations/pluresdb.js';
+import { createPraxisEngine, PraxisRegistry } from '../index.js';
+
+describe('Unum Integration', () => {
+  describe('createUnumAdapter', () => {
+    it('should create an adapter without identity', async () => {
       const db = createInMemoryDB();
       const adapter = await createUnumAdapter({ db });
-      
+
       expect(adapter).toBeDefined();
       expect(adapter.identity).toBeNull();
     });
-    
-    it("should create an adapter with identity", async () => {
+
+    it('should create an adapter with identity', async () => {
       const db = createInMemoryDB();
       const adapter = await createUnumAdapter({
         db,
         identity: {
-          id: "test-user",
-          name: "Test User",
+          id: 'test-user',
+          name: 'Test User',
           createdAt: Date.now(),
         },
       });
-      
+
       expect(adapter.identity).toBeDefined();
-      expect(adapter.identity?.name).toBe("Test User");
+      expect(adapter.identity?.name).toBe('Test User');
     });
-    
-    it("should set identity", async () => {
+
+    it('should set identity', async () => {
       const db = createInMemoryDB();
       const adapter = await createUnumAdapter({ db });
-      
-      const identity = await adapter.setIdentity({ name: "New User" });
-      
-      expect(identity.name).toBe("New User");
+
+      const identity = await adapter.setIdentity({ name: 'New User' });
+
+      expect(identity.name).toBe('New User');
       expect(identity.id).toBeDefined();
       expect(identity.createdAt).toBeDefined();
     });
-    
-    it("should get identity by ID", async () => {
+
+    it('should get identity by ID', async () => {
       const db = createInMemoryDB();
       const adapter = await createUnumAdapter({ db });
-      
-      const created = await adapter.setIdentity({ name: "Test" });
+
+      const created = await adapter.setIdentity({ name: 'Test' });
       const fetched = await adapter.getIdentity(created.id);
-      
+
       expect(fetched).toBeDefined();
-      expect(fetched?.name).toBe("Test");
+      expect(fetched?.name).toBe('Test');
     });
-    
-    it("should create a channel", async () => {
+
+    it('should create a channel', async () => {
       const db = createInMemoryDB();
       const adapter = await createUnumAdapter({ db });
-      
-      const channel = await adapter.createChannel("test-channel");
-      
+
+      const channel = await adapter.createChannel('test-channel');
+
       expect(channel).toBeDefined();
-      expect(channel.name).toBe("test-channel");
+      expect(channel.name).toBe('test-channel');
       expect(channel.id).toBeDefined();
     });
-    
-    it("should join a channel", async () => {
+
+    it('should join a channel', async () => {
       const db = createInMemoryDB();
       const adapter = await createUnumAdapter({ db });
-      
-      const created = await adapter.createChannel("test-channel");
+
+      const created = await adapter.createChannel('test-channel');
       const joined = await adapter.joinChannel(created.id);
-      
+
       expect(joined.id).toBe(created.id);
-      expect(joined.name).toBe("test-channel");
+      expect(joined.name).toBe('test-channel');
     });
-    
-    it("should list channels", async () => {
+
+    it('should list channels', async () => {
       const db = createInMemoryDB();
       const adapter = await createUnumAdapter({ db });
-      
-      await adapter.createChannel("channel-1");
-      await adapter.createChannel("channel-2");
-      
+
+      await adapter.createChannel('channel-1');
+      await adapter.createChannel('channel-2');
+
       const channels = await adapter.listChannels();
-      
+
       expect(channels.length).toBe(2);
     });
-    
-    it("should publish messages to channel", async () => {
+
+    it('should publish messages to channel', async () => {
       const db = createInMemoryDB();
       const adapter = await createUnumAdapter({
         db,
-        identity: { id: "user-1", name: "User 1", createdAt: Date.now() },
+        identity: { id: 'user-1', name: 'User 1', createdAt: Date.now() },
       });
-      
-      const channel = await adapter.createChannel("test-channel");
-      
+
+      const channel = await adapter.createChannel('test-channel');
+
       const messages: unknown[] = [];
       channel.subscribe((msg) => messages.push(msg));
-      
+
       await channel.publish({
-        id: "msg-1",
+        id: 'msg-1',
         sender: adapter.identity!,
-        content: { text: "Hello!" },
-        type: "text",
+        content: { text: 'Hello!' },
+        type: 'text',
       });
-      
+
       expect(messages.length).toBe(1);
     });
-    
-    it("should disconnect and cleanup", async () => {
+
+    it('should disconnect and cleanup', async () => {
       const db = createInMemoryDB();
       const adapter = await createUnumAdapter({ db });
-      
-      await adapter.createChannel("test-channel");
+
+      await adapter.createChannel('test-channel');
       await adapter.disconnect();
-      
+
       const channels = await adapter.listChannels();
       expect(channels.length).toBe(0);
       expect(adapter.identity).toBeNull();
     });
   });
-  
-  describe("attachUnumToEngine", () => {
-    it("should attach adapter to engine", async () => {
+
+  describe('attachUnumToEngine', () => {
+    it('should attach adapter to engine', async () => {
       const db = createInMemoryDB();
       const adapter = await createUnumAdapter({ db });
       const registry = new PraxisRegistry();
@@ -132,9 +132,9 @@ describe("Unum Integration", () => {
         initialContext: {},
         registry,
       });
-      
-      const cleanup = attachUnumToEngine(engine, adapter, "test-channel");
-      
+
+      const cleanup = attachUnumToEngine(engine, adapter, 'test-channel');
+
       expect(cleanup).toBeInstanceOf(Function);
       cleanup();
     });

package/src/adapters/cli.ts

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 /**
  * Praxis CLI Adapter
- * 
+ *
  * JSON-based CLI interface for cross-language Praxis engine invocation.
  * Reads JSON from stdin, processes through Praxis engine, outputs JSON to stdout.
- * 
+ *
  * This enables PowerShell, Python, and other languages to use Praxis.
  */
 
-import * as fs from "fs";
+import * as fs from 'fs';
 import {
   createPraxisEngine,
   PraxisRegistry,
@@ -17,7 +17,7 @@ import {
   type PraxisStepResult,
   type RuleDescriptor,
   type ConstraintDescriptor,
-} from "../index.js";
+} from '../index.js';
 
 interface CLIInput {
   state: PraxisState;
@@ -44,7 +44,7 @@ interface RegistryConfig {
  */
 function loadRegistryConfig(configPath: string): RegistryConfig {
   try {
-    const content = fs.readFileSync(configPath, "utf-8");
+    const content = fs.readFileSync(configPath, 'utf-8');
     return JSON.parse(content);
   } catch (error) {
     throw new Error(`Failed to load registry config from ${configPath}: ${error}`);
@@ -71,7 +71,7 @@ function createRegistryFromConfig<TContext = unknown>(
       // Eval the implementation (for demo purposes)
       // In production, load from modules or use a safer evaluation method
       const impl = eval(ruleConfig.impl);
-      
+
       const rule: RuleDescriptor<TContext> = {
         id: ruleConfig.id,
         description: ruleConfig.description,
@@ -92,7 +92,7 @@ function createRegistryFromConfig<TContext = unknown>(
 
     try {
       const impl = eval(constraintConfig.impl);
-      
+
       const constraint: ConstraintDescriptor<TContext> = {
         id: constraintConfig.id,
         description: constraintConfig.description,
@@ -134,14 +134,14 @@ function processStep(input: CLIInput): PraxisStepResult {
 async function main() {
   try {
     // Read input from stdin
-    let inputData = "";
-    
+    let inputData = '';
+
     for await (const chunk of process.stdin) {
       inputData += chunk;
     }
 
     if (!inputData.trim()) {
-      throw new Error("No input provided");
+      throw new Error('No input provided');
     }
 
     // Parse input
@@ -149,7 +149,7 @@ async function main() {
 
     // Validate input
     if (!input.state || !input.events || !input.configPath) {
-      throw new Error("Invalid input: must provide state, events, and configPath");
+      throw new Error('Invalid input: must provide state, events, and configPath');
     }
 
     // Process step
@@ -159,10 +159,16 @@ async function main() {
     console.log(JSON.stringify(result, null, 2));
     process.exit(0);
   } catch (error) {
-    console.error(JSON.stringify({
-      error: error instanceof Error ? error.message : String(error),
-      stack: error instanceof Error ? error.stack : undefined,
-    }, null, 2));
+    console.error(
+      JSON.stringify(
+        {
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : undefined,
+        },
+        null,
+        2
+      )
+    );
     process.exit(1);
   }
 }

package/src/cli/commands/auth.ts

@@ -1,19 +1,19 @@
 /**
  * Authentication CLI Commands
- * 
+ *
  * Commands for authenticating with GitHub for Praxis Cloud access.
  */
 
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import { authenticateWithDeviceFlow } from "../../cloud/auth.js";
-import { createSponsorsClient } from "../../cloud/sponsors.js";
-import type { AuthResult } from "../../cloud/types.js";
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { authenticateWithDeviceFlow } from '../../cloud/auth.js';
+import { createSponsorsClient } from '../../cloud/sponsors.js';
+import type { AuthResult } from '../../cloud/types.js';
 
-const AUTH_DIR = path.join(os.homedir(), ".praxis");
-const AUTH_FILE = path.join(AUTH_DIR, "auth.json");
-const GITHUB_CLIENT_ID = "Ov23liQxF7P0BqUxVXHk"; // Demo client ID (replace in production)
+const AUTH_DIR = path.join(os.homedir(), '.praxis');
+const AUTH_FILE = path.join(AUTH_DIR, 'auth.json');
+const GITHUB_CLIENT_ID = 'Ov23liQxF7P0BqUxVXHk'; // Demo client ID (replace in production)
 
 interface StoredAuth {
   token: string;
@@ -30,11 +30,11 @@ interface StoredAuth {
 function loadAuth(): StoredAuth | null {
   try {
     if (fs.existsSync(AUTH_FILE)) {
-      const data = fs.readFileSync(AUTH_FILE, "utf-8");
+      const data = fs.readFileSync(AUTH_FILE, 'utf-8');
       return JSON.parse(data);
     }
   } catch (error) {
-    console.warn("Failed to load authentication:", error);
+    console.warn('Failed to load authentication:', error);
   }
   return null;
 }
@@ -48,12 +48,12 @@ function saveAuth(auth: StoredAuth): void {
     if (!fs.existsSync(AUTH_DIR)) {
       fs.mkdirSync(AUTH_DIR, { recursive: true });
     }
-    
+
     // Save with restricted permissions
     fs.writeFileSync(AUTH_FILE, JSON.stringify(auth, null, 2), { mode: 0o600 });
     console.log(`\n✓ Authentication saved to ${AUTH_FILE}`);
   } catch (error) {
-    console.error("Failed to save authentication:", error);
+    console.error('Failed to save authentication:', error);
     throw error;
   }
 }
@@ -67,7 +67,7 @@ function deleteAuth(): void {
       fs.unlinkSync(AUTH_FILE);
     }
   } catch (error) {
-    console.warn("Failed to delete authentication:", error);
+    console.warn('Failed to delete authentication:', error);
   }
 }
 
@@ -75,40 +75,42 @@ function deleteAuth(): void {
  * Login command
  */
 export async function loginCommand(options: { token?: string }): Promise<void> {
-  console.log("\n╔═══════════════════════════════════════════════════╗");
-  console.log("║   Praxis Cloud Authentication                     ║");
-  console.log("╚═══════════════════════════════════════════════════╝\n");
-  
+  console.log('\n╔═══════════════════════════════════════════════════╗');
+  console.log('║   Praxis Cloud Authentication                     ║');
+  console.log('╚═══════════════════════════════════════════════════╝\n');
+
   // Check if already authenticated
   const existingAuth = loadAuth();
   if (existingAuth) {
-    console.log("⚠  Already authenticated");
+    console.log('⚠  Already authenticated');
     console.log(`   User: ${existingAuth.userLogin}`);
-    console.log(`   Authenticated at: ${new Date(existingAuth.authenticatedAt).toLocaleString()}\n`);
+    console.log(
+      `   Authenticated at: ${new Date(existingAuth.authenticatedAt).toLocaleString()}\n`
+    );
     console.log("Run 'praxis logout' to log out first.");
     return;
   }
-  
+
   let authResult: AuthResult;
-  
+
   if (options.token) {
     // Use provided token
-    console.log("🔐 Using provided personal access token...");
-    
+    console.log('🔐 Using provided personal access token...');
+
     try {
-      const response = await fetch("https://api.github.com/user", {
+      const response = await fetch('https://api.github.com/user', {
         headers: {
           Authorization: `Bearer ${options.token}`,
-          Accept: "application/vnd.github.v3+json",
+          Accept: 'application/vnd.github.v3+json',
         },
       });
-      
+
       if (!response.ok) {
         throw new Error(`Invalid token: ${response.statusText}`);
       }
-      
-      const userData = await response.json() as any;
-      
+
+      const userData = (await response.json()) as any;
+
       authResult = {
         success: true,
         token: options.token,
@@ -121,42 +123,42 @@ export async function loginCommand(options: { token?: string }): Promise<void> {
         },
       };
     } catch (error) {
-      console.error("\n✗ Authentication failed");
+      console.error('\n✗ Authentication failed');
       console.error(`  Error: ${error instanceof Error ? error.message : String(error)}`);
       process.exit(1);
     }
   } else {
     // Use device flow
-    console.log("🔐 Authenticating with GitHub device flow...");
+    console.log('🔐 Authenticating with GitHub device flow...');
     authResult = await authenticateWithDeviceFlow(GITHUB_CLIENT_ID);
   }
-  
+
   if (!authResult.success || !authResult.token || !authResult.user) {
-    console.error("\n✗ Authentication failed");
+    console.error('\n✗ Authentication failed');
     process.exit(1);
   }
-  
+
   console.log(`✓ Authenticated as ${authResult.user.login}`);
-  
+
   // Check GitHub Sponsors status
-  console.log("\n🔍 Checking GitHub Sponsors status...");
+  console.log('\n🔍 Checking GitHub Sponsors status...');
   try {
     const sponsorsClient = createSponsorsClient(authResult.token);
     const subscription = await sponsorsClient.getSubscription(authResult.user.login);
-    
+
     console.log(`✓ Subscription tier: ${subscription.tier}`);
     console.log(`  Status: ${subscription.status}`);
     console.log(`  Provider: ${subscription.provider}`);
-    
-    if (subscription.tier === "free") {
-      console.log("\n💡 Upgrade to a paid tier for more features!");
-      console.log("   Visit: https://github.com/sponsors/plures");
+
+    if (subscription.tier === 'free') {
+      console.log('\n💡 Upgrade to a paid tier for more features!');
+      console.log('   Visit: https://github.com/sponsors/plures');
     }
   } catch (error) {
-    console.warn("\n⚠  Could not check Sponsors status");
+    console.warn('\n⚠  Could not check Sponsors status');
     console.warn(`   Error: ${error instanceof Error ? error.message : String(error)}`);
   }
-  
+
   // Save authentication
   const storedAuth: StoredAuth = {
     token: authResult.token,
@@ -166,11 +168,11 @@ export async function loginCommand(options: { token?: string }): Promise<void> {
     userEmail: authResult.user.email,
     authenticatedAt: Date.now(),
   };
-  
+
   saveAuth(storedAuth);
-  
-  console.log("\n✓ Successfully logged in!");
-  console.log("\nNext steps:");
+
+  console.log('\n✓ Successfully logged in!');
+  console.log('\nNext steps:');
   console.log("  • Use 'praxis cloud init' to set up cloud connection");
   console.log("  • Use 'praxis whoami' to check your authentication");
   console.log("  • Use 'praxis cloud status' to check subscription\n");
@@ -181,18 +183,18 @@ export async function loginCommand(options: { token?: string }): Promise<void> {
  */
 export async function logoutCommand(): Promise<void> {
   const auth = loadAuth();
-  
+
   if (!auth) {
-    console.log("\n✗ Not currently logged in");
+    console.log('\n✗ Not currently logged in');
     console.log("  Run 'praxis login' to authenticate\n");
     return;
   }
-  
+
   console.log(`\nLogging out user: ${auth.userLogin}...`);
-  
+
   deleteAuth();
-  
-  console.log("✓ Successfully logged out\n");
+
+  console.log('✓ Successfully logged out\n');
 }
 
 /**
@@ -200,17 +202,17 @@ export async function logoutCommand(): Promise<void> {
  */
 export async function whoamiCommand(): Promise<void> {
   const auth = loadAuth();
-  
+
   if (!auth) {
-    console.log("\n✗ Not currently logged in");
+    console.log('\n✗ Not currently logged in');
     console.log("  Run 'praxis login' to authenticate\n");
     process.exit(1);
   }
-  
-  console.log("\n╔═══════════════════════════════════════════════════╗");
-  console.log("║   Current Authentication                          ║");
-  console.log("╚═══════════════════════════════════════════════════╝\n");
-  
+
+  console.log('\n╔═══════════════════════════════════════════════════╗');
+  console.log('║   Current Authentication                          ║');
+  console.log('╚═══════════════════════════════════════════════════╝\n');
+
   console.log(`User: ${auth.userLogin}`);
   if (auth.userName) {
     console.log(`Name: ${auth.userName}`);
@@ -220,49 +222,51 @@ export async function whoamiCommand(): Promise<void> {
   }
   console.log(`User ID: ${auth.userId}`);
   console.log(`Authenticated: ${new Date(auth.authenticatedAt).toLocaleString()}`);
-  
+
   // Check token validity
-  console.log("\n🔍 Checking token validity...");
+  console.log('\n🔍 Checking token validity...');
   try {
-    const response = await fetch("https://api.github.com/user", {
+    const response = await fetch('https://api.github.com/user', {
       headers: {
         Authorization: `Bearer ${auth.token}`,
-        Accept: "application/vnd.github.v3+json",
+        Accept: 'application/vnd.github.v3+json',
       },
     });
-    
+
     if (response.ok) {
-      console.log("✓ Token is valid");
-      
+      console.log('✓ Token is valid');
+
       // Check subscription
-      console.log("\n🔍 Checking subscription...");
+      console.log('\n🔍 Checking subscription...');
       const sponsorsClient = createSponsorsClient(auth.token);
       const subscription = await sponsorsClient.getSubscription(auth.userLogin);
-      
+
       console.log(`Tier: ${subscription.tier}`);
       console.log(`Status: ${subscription.status}`);
       console.log(`Provider: ${subscription.provider}`);
-      console.log("\nLimits:");
+      console.log('\nLimits:');
       console.log(`  Syncs/month: ${subscription.limits.maxSyncsPerMonth.toLocaleString()}`);
-      console.log(`  Storage: ${(subscription.limits.maxStorageBytes / 1024 / 1024).toFixed(0)} MB`);
+      console.log(
+        `  Storage: ${(subscription.limits.maxStorageBytes / 1024 / 1024).toFixed(0)} MB`
+      );
       console.log(`  Apps: ${subscription.limits.maxApps}`);
-      console.log(`  Team members: ${subscription.limits.maxTeamMembers ?? "Unlimited"}`);
+      console.log(`  Team members: ${subscription.limits.maxTeamMembers ?? 'Unlimited'}`);
       console.log(`  Support: ${subscription.limits.supportLevel}`);
     } else {
-      console.log("✗ Token is invalid or expired");
+      console.log('✗ Token is invalid or expired');
       console.log("  Run 'praxis login' to re-authenticate");
     }
   } catch (error) {
-    console.error("\n✗ Failed to check token validity");
+    console.error('\n✗ Failed to check token validity');
     console.error(`  Error: ${error instanceof Error ? error.message : String(error)}`);
   }
-  
+
   console.log();
 }
 
 /**
  * Get stored authentication token
- * 
+ *
  * Used by other commands that need authentication
  */
 export function getAuthToken(): string | null {