@plures/praxis 1.0.2 → 1.1.0

package/src/cli/commands/generate.ts

@@ -1,6 +1,6 @@
 /**
  * Praxis Generate Command
- * 
+ *
  * Generates code from Praxis schema files.
  */
 
@@ -36,50 +36,48 @@ export async function generate(options: GenerateOptions): Promise<void> {
     // Determine schema file path
     const schemaPath = options.schema || './praxis.schema.js';
     const resolvedSchemaPath = resolve(process.cwd(), schemaPath);
-    
+
     console.log(`Loading schema from: ${resolvedSchemaPath}`);
-    
+
     // Load the schema
     const loadResult = await loadSchemaFromFile(resolvedSchemaPath, {
       validate: true,
     });
-    
+
     if (loadResult.errors.length > 0) {
       console.error('❌ Failed to load schema:');
       loadResult.errors.forEach((error) => console.error(`  - ${error}`));
       process.exit(1);
     }
-    
+
     if (!loadResult.schema) {
       console.error('❌ No schema found');
       process.exit(1);
     }
-    
+
     // Validate schema for generation
     const generationValidation = validateForGeneration(loadResult.schema);
     if (!generationValidation.valid) {
       console.error('❌ Schema validation failed:');
-      generationValidation.errors.forEach((error) =>
-        console.error(`  - ${error.message}`)
-      );
+      generationValidation.errors.forEach((error) => console.error(`  - ${error.message}`));
       process.exit(1);
     }
-    
+
     console.log('✓ Schema loaded successfully');
-    
+
     // Normalize the schema
     console.log('Normalizing schema...');
     const normalizedSchema = normalizeSchema(loadResult.schema);
     console.log('✓ Schema normalized');
-    
+
     // Determine output directory
     const outputDir = options.output || './generated';
     const resolvedOutputDir = resolve(process.cwd(), outputDir);
-    
+
     // Generate based on target
     const target = options.target || 'all';
     let generatedFiles = 0;
-    
+
     if (target === 'all' || target === 'logic') {
       console.log('\nGenerating logic module...');
       const logicOutputDir = `${resolvedOutputDir}/logic`;
@@ -87,18 +85,15 @@ export async function generate(options: GenerateOptions): Promise<void> {
       generatedFiles += 5; // facts, events, rules, engine, index
       console.log(`✓ Logic module generated in ${logicOutputDir}`);
     }
-    
+
     if (target === 'all' || target === 'components') {
       console.log('\nGenerating components...');
       const componentsOutputDir = `${resolvedOutputDir}/components`;
-      const componentCount = await generateComponents(
-        normalizedSchema,
-        componentsOutputDir
-      );
+      const componentCount = await generateComponents(normalizedSchema, componentsOutputDir);
       generatedFiles += componentCount;
       console.log(`✓ ${componentCount} components generated in ${componentsOutputDir}`);
     }
-    
+
     if (target === 'all' || target === 'pluresdb') {
       console.log('\nGenerating PluresDB configuration...');
       const dbOutputDir = resolvedOutputDir;
@@ -106,9 +101,9 @@ export async function generate(options: GenerateOptions): Promise<void> {
       generatedFiles += 1;
       console.log(`✓ PluresDB config generated in ${dbOutputDir}`);
     }
-    
+
     console.log(`\n✅ Generation complete! ${generatedFiles} files generated.`);
-    
+
     if (options.watch) {
       console.log('\n👀 Watching for changes...');
       console.log('(Watch mode not yet implemented)');
@@ -130,13 +125,10 @@ export async function generate(options: GenerateOptions): Promise<void> {
 /**
  * Generate logic module
  */
-async function generateLogic(
-  schema: NormalizedSchema,
-  outputDir: string
-): Promise<void> {
+async function generateLogic(schema: NormalizedSchema, outputDir: string): Promise<void> {
   const generator = createLogicGenerator(outputDir);
   const files = generator.generateLogic(schema);
-  
+
   // Write files
   for (const file of files) {
     await ensureDir(dirname(file.path));
@@ -147,35 +139,32 @@ async function generateLogic(
 /**
  * Generate components
  */
-async function generateComponents(
-  schema: NormalizedSchema,
-  outputDir: string
-): Promise<number> {
+async function generateComponents(schema: NormalizedSchema, outputDir: string): Promise<number> {
   if (!schema.components || schema.components.length === 0) {
     console.log('  No components defined in schema');
     return 0;
   }
-  
+
   const generator = createComponentGenerator(outputDir, {
     typescript: true,
     includeTests: false,
     includeDocs: true,
   });
-  
+
   let fileCount = 0;
-  
+
   for (const component of schema.components) {
     // Find model if component references one
     const model = component.resolvedModel || undefined;
-    
+
     const result = generator.generateComponent(component, model);
-    
+
     if (!result.success) {
       console.error(`  ⚠️  Failed to generate ${component.name}:`);
       result.errors.forEach((error) => console.error(`    - ${error.message}`));
       continue;
     }
-    
+
     // Write files
     for (const file of result.files) {
       await ensureDir(dirname(file.path));
@@ -183,7 +172,7 @@ async function generateComponents(
       fileCount++;
     }
   }
-  
+
   return fileCount;
 }
 
@@ -200,9 +189,9 @@ async function generatePluresDB(
     enableSync: false,
     autoIndex: autoIndex || 'all',
   });
-  
+
   const files = generator.generateConfig(schema);
-  
+
   // Write files
   for (const file of files) {
     await ensureDir(dirname(file.path));

package/src/cli/commands/orchestrate.ts

@@ -1,6 +1,6 @@
 /**
  * Orchestrate Command
- * 
+ *
  * Manages distributed orchestration and coordination.
  */
 
@@ -47,11 +47,11 @@ export interface OrchestrateOptions {
  */
 export async function orchestrate(options: OrchestrateOptions): Promise<void> {
   const action = options.action || 'status';
-  
+
   console.log('\n╔═══════════════════════════════════════════════════╗');
   console.log('║   Praxis Orchestration                            ║');
   console.log('╚═══════════════════════════════════════════════════╝\n');
-  
+
   switch (action) {
     case 'init':
       await initOrchestration(options);
@@ -73,13 +73,13 @@ export async function orchestrate(options: OrchestrateOptions): Promise<void> {
  */
 async function initOrchestration(options: OrchestrateOptions): Promise<void> {
   const configPath = options.config || 'praxis.orchestrate.json';
-  
+
   if (fs.existsSync(configPath)) {
     console.log(`Configuration file already exists: ${configPath}`);
     console.log('Use --config to specify a different file.\n');
     return;
   }
-  
+
   const defaultConfig: OrchestrationConfig = {
     nodeId: `node-${Date.now().toString(36)}`,
     role: 'primary',
@@ -95,9 +95,9 @@ async function initOrchestration(options: OrchestrateOptions): Promise<void> {
       timeout: 5000,
     },
   };
-  
+
   fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2));
-  
+
   console.log(`✓ Created orchestration config: ${configPath}`);
   console.log('\nConfiguration:');
   console.log(`  Node ID: ${defaultConfig.nodeId}`);
@@ -114,42 +114,42 @@ async function initOrchestration(options: OrchestrateOptions): Promise<void> {
  */
 async function startOrchestration(options: OrchestrateOptions): Promise<void> {
   const configPath = options.config || 'praxis.orchestrate.json';
-  
+
   if (!fs.existsSync(configPath)) {
     console.log(`Configuration file not found: ${configPath}`);
     console.log('\nTo create a configuration:');
     console.log('  praxis orchestrate --action init\n');
     return;
   }
-  
+
   const config: OrchestrationConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-  
+
   console.log('Starting orchestration...\n');
   console.log(`  Node ID: ${config.nodeId}`);
   console.log(`  Role: ${config.role}`);
   console.log(`  Endpoints: ${config.endpoints.join(', ')}\n`);
-  
+
   // In a real implementation, this would:
   // 1. Connect to cluster endpoints
   // 2. Register node with cluster
   // 3. Start sync worker
   // 4. Start health check worker
-  
+
   console.log('🔄 Connecting to cluster...');
-  
+
   // Simulate connection delay
-  await new Promise(resolve => setTimeout(resolve, 500));
-  
+  await new Promise((resolve) => setTimeout(resolve, 500));
+
   console.log('✓ Connected to cluster');
   console.log('✓ Sync worker started');
   console.log('✓ Health check enabled\n');
-  
+
   console.log('Orchestration is running.');
   console.log('\nTo check status:');
   console.log('  praxis orchestrate --action status\n');
   console.log('To stop:');
   console.log('  praxis orchestrate --action stop\n');
-  
+
   // For a full implementation, this would keep running
   // and handle sync/health checks in the background
 }
@@ -159,16 +159,16 @@ async function startOrchestration(options: OrchestrateOptions): Promise<void> {
  */
 async function stopOrchestration(_options: OrchestrateOptions): Promise<void> {
   console.log('Stopping orchestration...\n');
-  
+
   // In a real implementation, this would:
   // 1. Stop sync worker
   // 2. Unregister from cluster
   // 3. Close connections
-  
+
   console.log('✓ Sync worker stopped');
   console.log('✓ Unregistered from cluster');
   console.log('✓ Connections closed\n');
-  
+
   console.log('Orchestration stopped.\n');
 }
 
@@ -177,7 +177,7 @@ async function stopOrchestration(_options: OrchestrateOptions): Promise<void> {
  */
 async function showOrchestrationStatus(options: OrchestrateOptions): Promise<void> {
   const configPath = options.config || 'praxis.orchestrate.json';
-  
+
   if (!fs.existsSync(configPath)) {
     console.log('Orchestration not configured.\n');
     console.log('To initialize:');
@@ -188,9 +188,9 @@ async function showOrchestrationStatus(options: OrchestrateOptions): Promise<voi
     console.log('  • See docs/guides/orchestration.md for patterns\n');
     return;
   }
-  
+
   const config: OrchestrationConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-  
+
   console.log('Orchestration Status\n');
   console.log('┌──────────────────────────────────────────────────┐');
   console.log(`│ Node ID:     ${config.nodeId.padEnd(36)} │`);
@@ -206,7 +206,7 @@ async function showOrchestrationStatus(options: OrchestrateOptions): Promise<voi
   console.log(`│ Timeout:     ${(config.health.timeout + 'ms').padEnd(36)} │`);
   console.log('└──────────────────────────────────────────────────┘\n');
   console.log('Endpoints:');
-  config.endpoints.forEach(ep => console.log(`  • ${ep}`));
+  config.endpoints.forEach((ep) => console.log(`  • ${ep}`));
   console.log('\nTo start orchestration:');
   console.log(`  praxis orchestrate --action start --config ${configPath}\n`);
 }

package/src/cli/commands/verify.ts

@@ -0,0 +1,49 @@
+/**
+ * Verify Command
+ *
+ * Verifies the implementation of the project against the schema/rules.
+ */
+
+import { verifyImplementation } from '../../../ui/canvas-inspector/src/verify-fsm-implementation.js';
+
+export interface VerifyOptions {
+  detailed?: boolean;
+}
+
+export async function verify(type: string, _options: VerifyOptions): Promise<void> {
+  if (type !== 'implementation') {
+    console.error(`Unknown verification type: ${type}`);
+    console.log('Supported types: implementation');
+    process.exit(1);
+  }
+
+  console.log('Verifying FSM implementation...');
+
+  try {
+    const result = verifyImplementation();
+
+    const missingCount = result.missingHandlers.length;
+    const emptyCount = result.emptyHandlers.length;
+
+    if (missingCount === 0 && emptyCount === 0) {
+      console.log('✅ Verification passed! All rules have implementations.');
+    } else {
+      console.log('⚠️  Verification found issues:');
+
+      if (missingCount > 0) {
+        console.log(`\n  Missing Handlers (${missingCount}):`);
+        result.missingHandlers.forEach((h: string) => console.log(`    - ${h}`));
+      }
+
+      if (emptyCount > 0) {
+        console.log(`\n  Empty Handlers (${emptyCount}):`);
+        result.emptyHandlers.forEach((h: string) => console.log(`    - ${h}`));
+      }
+
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error('Verification failed:', error);
+    process.exit(1);
+  }
+}

package/src/cli/index.ts

@@ -2,7 +2,7 @@
 
 /**
  * Praxis CLI
- * 
+ *
  * Command-line interface for the Praxis framework.
  */
 
@@ -81,7 +81,11 @@ program
   .option('-t, --target <target>', 'Generation target (all, logic, components, pluresdb)', 'all')
   .option('-o, --output <dir>', 'Output directory', './generated')
   .option('-w, --watch', 'Watch for changes')
-  .option('--auto-index <strategy>', 'Auto-indexing strategy for PluresDB (all, explicit, none)', 'all')
+  .option(
+    '--auto-index <strategy>',
+    'Auto-indexing strategy for PluresDB (all, explicit, none)',
+    'all'
+  )
   .action(async (options) => {
     await generate(options);
   });
@@ -214,4 +218,19 @@ cloudCmd
     }
   });
 
+// Verify command
+program
+  .command('verify <type>')
+  .description('Verify project implementation (e.g., implementation)')
+  .option('-d, --detailed', 'Show detailed analysis')
+  .action(async (type, options) => {
+    try {
+      const { verify } = await import('./commands/verify.js');
+      await verify(type, options);
+    } catch (error) {
+      console.error('Error verifying:', error);
+      process.exit(1);
+    }
+  });
+
 program.parse();

package/src/cloud/README.md

@@ -24,6 +24,7 @@ npx praxis cloud init
 ```
 
 The wizard will:
+
 1. Authenticate with GitHub
 2. Configure the Azure endpoint
 3. Test the connection
@@ -32,24 +33,24 @@ The wizard will:
 ### 2. Use in Your Application
 
 ```typescript
-import { connectRelay } from "@plures/praxis/cloud";
+import { connectRelay } from '@plures/praxis/cloud';
 
 // Connect to cloud relay
-const relay = await connectRelay("https://praxis-relay.azurewebsites.net", {
-  appId: "my-app",
-  authToken: "your-github-token",
+const relay = await connectRelay('https://praxis-relay.azurewebsites.net', {
+  appId: 'my-app',
+  authToken: 'your-github-token',
   autoSync: true,
-  syncInterval: 5000
+  syncInterval: 5000,
 });
 
 // Sync data
 await relay.sync({
-  type: "delta",
-  appId: "my-app",
+  type: 'delta',
+  appId: 'my-app',
   clock: {},
-  facts: [{ tag: "TaskCreated", payload: { id: "1", title: "Buy milk" } }],
+  facts: [{ tag: 'TaskCreated', payload: { id: '1', title: 'Buy milk' } }],
   events: [],
-  timestamp: Date.now()
+  timestamp: Date.now(),
 });
 
 // Get usage metrics
@@ -75,6 +76,7 @@ npx praxis cloud init --endpoint https://praxis-relay.azurewebsites.net --app-id
 ```
 
 Options:
+
 - `-e, --endpoint <url>` - Azure Function App endpoint URL
 - `-a, --app-id <id>` - Application identifier
 - `--auto-sync` - Enable automatic synchronization
@@ -111,6 +113,7 @@ npx praxis cloud usage
 Connect to Praxis Cloud Relay.
 
 **Parameters:**
+
 - `endpoint: string` - Azure Function App endpoint URL
 - `options: CloudRelayConfig` - Configuration options
   - `appId: string` - Application identifier (required)
@@ -136,6 +139,7 @@ Disconnect from the relay service.
 Sync facts and events using CRDT protocol.
 
 **Parameters:**
+
 - `message.type` - "sync" | "delta" | "snapshot"
 - `message.appId` - Application identifier
 - `message.clock` - Vector clock for causality
@@ -148,6 +152,7 @@ Sync facts and events using CRDT protocol.
 Get usage metrics for the current billing period.
 
 **Returns:**
+
 - `syncCount` - Number of sync operations
 - `eventCount` - Number of events forwarded
 - `factCount` - Number of facts synced
@@ -160,6 +165,7 @@ Get usage metrics for the current billing period.
 Get service health status.
 
 **Returns:**
+
 - `status` - "healthy" | "degraded" | "unhealthy"
 - `services` - Status of individual services
   - `relay` - Relay service status
@@ -172,6 +178,7 @@ Get service health status.
 Get current connection status (synchronous).
 
 **Returns:**
+
 - `connected` - Connection state
 - `lastSync` - Last sync timestamp
 - `endpoint` - Endpoint URL
@@ -233,6 +240,7 @@ The relay exposes the following HTTP endpoints:
 Health check endpoint.
 
 **Response:**
+
 ```json
 {
   "status": "healthy",
@@ -252,6 +260,7 @@ Health check endpoint.
 CRDT synchronization endpoint.
 
 **Request:**
+
 ```json
 {
   "type": "delta",
@@ -264,6 +273,7 @@ CRDT synchronization endpoint.
 ```
 
 **Response:**
+
 ```json
 {
   "success": true,
@@ -277,6 +287,7 @@ CRDT synchronization endpoint.
 Usage metrics endpoint.
 
 **Response:**
+
 ```json
 {
   "appId": "my-app",
@@ -294,6 +305,7 @@ Usage metrics endpoint.
 Aggregated statistics endpoint.
 
 **Response:**
+
 ```json
 {
   "appId": "my-app",
@@ -312,9 +324,9 @@ Praxis Cloud uses GitHub OAuth for authentication.
 The CLI uses GitHub's device flow for authentication:
 
 ```typescript
-import { authenticateWithDeviceFlow } from "@plures/praxis/cloud";
+import { authenticateWithDeviceFlow } from '@plures/praxis/cloud';
 
-const result = await authenticateWithDeviceFlow("your-client-id");
+const result = await authenticateWithDeviceFlow('your-client-id');
 
 if (result.success) {
   console.log(`Authenticated as ${result.user.login}`);
@@ -327,12 +339,12 @@ if (result.success) {
 For web applications, use the standard OAuth flow:
 
 ```typescript
-import { createGitHubOAuth } from "@plures/praxis/cloud";
+import { createGitHubOAuth } from '@plures/praxis/cloud';
 
 const oauth = createGitHubOAuth({
-  clientId: "your-client-id",
-  clientSecret: "your-client-secret",
-  redirectUri: "http://localhost:3000/callback"
+  clientId: 'your-client-id',
+  clientSecret: 'your-client-secret',
+  redirectUri: 'http://localhost:3000/callback',
 });
 
 // Redirect user to GitHub
@@ -368,6 +380,7 @@ Praxis Cloud Base Tier includes:
 - **GitHub OAuth** - Unlimited authentications
 
 Additional usage is billed per:
+
 - Sync operations: $0.001 per sync
 - Events: $0.0001 per event
 - Storage: $0.10 per GB/month