@plures/praxis 1.0.2 → 1.1.0

package/core/codegen/docs-generator.ts

@@ -1,6 +1,6 @@
 /**
  * Documentation Generator
- * 
+ *
  * Generates Markdown documentation from PSF schemas.
  * Produces API docs, architecture diagrams, and user guides.
  */
@@ -802,7 +802,10 @@ export function createDocsGenerator(options?: DocsGeneratorOptions): DocsGenerat
 /**
  * Generate documentation from PSF schema (convenience function)
  */
-export function generateDocs(schema: PSFSchema, options?: DocsGeneratorOptions): DocsGenerationResult {
+export function generateDocs(
+  schema: PSFSchema,
+  options?: DocsGeneratorOptions
+): DocsGenerationResult {
   const generator = new DocsGenerator(options);
   return generator.generate(schema);
 }

package/core/codegen/index.ts

@@ -1,6 +1,6 @@
 /**
  * Praxis Code Generation
- * 
+ *
  * Centralized code generation from PSF schemas.
  * Generates TypeScript, Svelte components, and documentation.
  */

package/core/codegen/ts-generator.ts

@@ -1,15 +1,15 @@
-/**
- * TypeScript Generator
- * 
- * Generates TypeScript types and code from PSF schemas.
- * Re-exports from schema-engine for convenience.
- */
-
-export {
-  PSFGenerator,
-  createPSFGenerator,
-  generateFromPSF,
-  type GeneratorOptions,
-  type GeneratedFile,
-  type GenerationResult,
-} from '../schema-engine/generator.js';
+/**
+ * TypeScript Generator
+ * 
+ * Generates TypeScript types and code from PSF schemas.
+ * Re-exports from schema-engine for convenience.
+ */
+
+export {
+  PSFGenerator,
+  createPSFGenerator,
+  generateFromPSF,
+  type GeneratorOptions,
+  type GeneratedFile,
+  type GenerationResult,
+} from '../schema-engine/generator.js';

package/core/db-adapter/index.ts

@@ -1,9 +1,9 @@
 /**
  * Praxis DB Adapter
- * 
+ *
  * The DB Adapter module provides integration with PluresDB
  * for local-first, reactive data storage and synchronization.
- * 
+ *
  * Features:
  * - Schema-backed storage
  * - Real-time synchronization

package/core/db-adapter/sync-engine.ts

@@ -1,9 +1,9 @@
 /**
  * PSF Schema Sync Engine
- * 
+ *
  * Provides real-time bidirectional synchronization between
  * Code ↔ PSF Schema ↔ Canvas using PluresDB as the sync backend.
- * 
+ *
  * The sync engine ensures that:
  * 1. Schema changes propagate to all connected clients in real-time
  * 2. Conflicts are resolved using CRDT-style last-write-wins with metadata
@@ -63,7 +63,7 @@ export interface SyncStatus {
 
 /**
  * Schema Sync Engine
- * 
+ *
  * Manages real-time synchronization of PSF schemas.
  */
 export class SchemaSyncEngine {
@@ -292,7 +292,15 @@ export class SchemaSyncEngine {
     const changes: SchemaChangeEvent[] = [];
     const now = Date.now();
 
-    const keys: (keyof PSFSchema)[] = ['facts', 'events', 'rules', 'constraints', 'models', 'components', 'flows'];
+    const keys: (keyof PSFSchema)[] = [
+      'facts',
+      'events',
+      'rules',
+      'constraints',
+      'models',
+      'components',
+      'flows',
+    ];
 
     for (const key of keys) {
       const oldArray = oldSchema[key] as unknown[];
@@ -354,7 +362,7 @@ export function createSchemaSyncEngine(options: SchemaSyncOptions): SchemaSyncEn
 
 /**
  * Schema store for PluresDB
- * 
+ *
  * Provides a higher-level API for storing and managing PSF schemas.
  */
 export class PSFSchemaStore {
@@ -414,7 +422,10 @@ export class PSFSchemaStore {
   /**
    * Get or create a sync engine for a schema
    */
-  async getSyncEngine(schemaId: string, options?: Partial<SchemaSyncOptions>): Promise<SchemaSyncEngine> {
+  async getSyncEngine(
+    schemaId: string,
+    options?: Partial<SchemaSyncOptions>
+  ): Promise<SchemaSyncEngine> {
     if (this.syncEngines.has(schemaId)) {
       return this.syncEngines.get(schemaId)!;
     }

package/core/logic-engine/engine.ts

@@ -1,6 +1,6 @@
 /**
  * Logic Engine Core
- * 
+ *
  * Re-exports the logic engine from the main source.
  * This provides a modular entry point for the logic engine.
  */

package/core/logic-engine/index.ts

@@ -1,12 +1,12 @@
 /**
  * Praxis Logic Engine
- * 
+ *
  * The Logic Engine is the core module responsible for:
  * - Processing events through rules
  * - Checking constraints
  * - Managing state transitions
  * - Schema-driven rule evaluation
- * 
+ *
  * The engine is pure and deterministic - all state updates are immutable.
  */
 

package/core/logic-engine/protocol.ts

@@ -1,6 +1,6 @@
 /**
  * Praxis Protocol
- * 
+ *
  * Re-exports the core protocol from the main source.
  */
 

package/core/logic-engine/psf-adapter.ts

@@ -1,6 +1,6 @@
 /**
  * PSF-Aware Logic Engine Adapter
- * 
+ *
  * This module connects the logic engine to the Praxis Schema Format (PSF).
  * It enables schema-driven rule evaluation and constraint checking.
  */
@@ -29,7 +29,7 @@ interface CompiledExpression {
 
 /**
  * PSF Adapter for Logic Engine
- * 
+ *
  * Converts PSF rules and constraints to logic engine format.
  */
 export class PSFLogicAdapter {
@@ -108,7 +108,9 @@ export class PSFLogicAdapter {
   /**
    * Convert PSF constraints to logic engine constraint descriptors
    */
-  convertConstraints<TContext = unknown>(constraints: PSFConstraint[]): ConstraintDescriptor<TContext>[] {
+  convertConstraints<TContext = unknown>(
+    constraints: PSFConstraint[]
+  ): ConstraintDescriptor<TContext>[] {
     return constraints.map((constraint) => this.convertConstraint<TContext>(constraint));
   }
 
@@ -142,7 +144,9 @@ export class PSFLogicAdapter {
   /**
    * Load a complete PSF schema into the logic engine
    */
-  loadSchema<TContext = unknown>(schema: PSFSchema): {
+  loadSchema<TContext = unknown>(
+    schema: PSFSchema
+  ): {
     rules: RuleDescriptor<TContext>[];
     constraints: ConstraintDescriptor<TContext>[];
   } {

package/core/logic-engine/rules.ts

@@ -1,6 +1,6 @@
 /**
  * Rules and Constraints
- * 
+ *
  * Re-exports rules and constraints from the main source.
  */
 

package/core/schema-engine/compiler.ts

@@ -1,6 +1,6 @@
 /**
  * PSF Compiler
- * 
+ *
  * Compiles TypeScript DSL definitions to PSF format.
  * This enables code → schema synchronization.
  */
@@ -24,13 +24,49 @@ import { PSF_VERSION, generatePSFId } from './psf.js';
  * Reserved JavaScript keywords (O(1) lookup)
  */
 const RESERVED_KEYWORDS = new Set([
-  'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger',
-  'default', 'delete', 'do', 'else', 'export', 'extends', 'finally',
-  'for', 'function', 'if', 'import', 'in', 'instanceof', 'new',
-  'return', 'super', 'switch', 'this', 'throw', 'try', 'typeof',
-  'var', 'void', 'while', 'with', 'yield', 'let', 'static',
-  'enum', 'await', 'implements', 'interface', 'package', 'private',
-  'protected', 'public',
+  'break',
+  'case',
+  'catch',
+  'class',
+  'const',
+  'continue',
+  'debugger',
+  'default',
+  'delete',
+  'do',
+  'else',
+  'export',
+  'extends',
+  'finally',
+  'for',
+  'function',
+  'if',
+  'import',
+  'in',
+  'instanceof',
+  'new',
+  'return',
+  'super',
+  'switch',
+  'this',
+  'throw',
+  'try',
+  'typeof',
+  'var',
+  'void',
+  'while',
+  'with',
+  'yield',
+  'let',
+  'static',
+  'enum',
+  'await',
+  'implements',
+  'interface',
+  'package',
+  'private',
+  'protected',
+  'public',
 ]);
 
 /**
@@ -183,7 +219,10 @@ export class PSFCompiler {
         warnings: this.warnings,
       };
     } catch (error) {
-      this.addError('compilation-failed', error instanceof Error ? error.message : 'Unknown compilation error');
+      this.addError(
+        'compilation-failed',
+        error instanceof Error ? error.message : 'Unknown compilation error'
+      );
       return {
         success: false,
         errors: this.errors,
@@ -364,13 +403,16 @@ export class PSFCompiler {
 
     // Handle enum types
     if (typeStr.startsWith('enum:')) {
-      const values = typeStr.slice(5).split('|').map((v) => v.trim());
+      const values = typeStr
+        .slice(5)
+        .split('|')
+        .map((v) => v.trim());
       return { enum: values };
     }
 
     // Handle basic types
     const basicTypes = ['string', 'number', 'boolean', 'date', 'datetime', 'uuid'] as const;
-    if (basicTypes.includes(typeStr as typeof basicTypes[number])) {
+    if (basicTypes.includes(typeStr as (typeof basicTypes)[number])) {
       return typeStr as PSFFieldType;
     }
 

package/core/schema-engine/generator.ts

@@ -1,6 +1,6 @@
 /**
  * PSF Generator
- * 
+ *
  * Generates TypeScript DSL code from PSF schema.
  * This enables schema → code synchronization.
  */
@@ -150,7 +150,9 @@ export class PSFGenerator {
       }
 
       const payloadType = this.generatePayloadType(fact.payload);
-      lines.push(`export const ${fact.tag} = defineFact<"${fact.tag}", ${payloadType}>("${fact.tag}");`);
+      lines.push(
+        `export const ${fact.tag} = defineFact<"${fact.tag}", ${payloadType}>("${fact.tag}");`
+      );
       lines.push('');
     }
 
@@ -182,7 +184,9 @@ export class PSFGenerator {
       }
 
       const payloadType = this.generatePayloadType(event.payload);
-      lines.push(`export const ${event.tag} = defineEvent<"${event.tag}", ${payloadType}>("${event.tag}");`);
+      lines.push(
+        `export const ${event.tag} = defineEvent<"${event.tag}", ${payloadType}>("${event.tag}");`
+      );
       lines.push('');
     }
 
@@ -390,7 +394,9 @@ export class PSFGenerator {
       if (component.props.length > 0) {
         lines.push(`  props: [`);
         for (const prop of component.props) {
-          lines.push(`    { name: '${prop.name}', type: '${prop.type}', required: ${prop.required ?? false} },`);
+          lines.push(
+            `    { name: '${prop.name}', type: '${prop.type}', required: ${prop.required ?? false} },`
+          );
         }
         lines.push(`  ],`);
       }
@@ -398,7 +404,9 @@ export class PSFGenerator {
       if (component.events.length > 0) {
         lines.push(`  events: [`);
         for (const event of component.events) {
-          lines.push(`    { name: '${event.name}'${event.payload ? `, payload: '${event.payload}'` : ''} },`);
+          lines.push(
+            `    { name: '${event.name}'${event.payload ? `, payload: '${event.payload}'` : ''} },`
+          );
         }
         lines.push(`  ],`);
       }
@@ -525,7 +533,9 @@ export class PSFGenerator {
   /**
    * Generate TypeScript type from payload schema
    */
-  private generatePayloadType(payload: { properties: Record<string, { type: PSFFieldType | string; description?: string }> }): string {
+  private generatePayloadType(payload: {
+    properties: Record<string, { type: PSFFieldType | string; description?: string }>;
+  }): string {
     const props = Object.entries(payload.properties)
       .map(([key, value]) => `${key}: ${this.fieldTypeToTS(value.type)}`)
       .join('; ');
@@ -611,7 +621,7 @@ export class PSFGenerator {
    */
   private escapeString(str: string): string {
     return str
-      .replace(/\\/g, '\\\\')  // Escape backslashes first
+      .replace(/\\/g, '\\\\') // Escape backslashes first
       .replace(/'/g, "\\'")
       .replace(/\n/g, '\\n')
       .replace(/\r/g, '\\r')

package/core/schema-engine/index.ts

@@ -1,12 +1,12 @@
 /**
  * Praxis Schema Engine
- * 
+ *
  * The Schema Engine is the central module responsible for:
  * - Parsing and validating Praxis Schema Format (PSF)
  * - Compiling TS DSL to PSF
  * - Generating TS DSL from PSF
  * - Managing schema transformations
- * 
+ *
  * PSF (Praxis Schema Format) is the canonical JSON/AST representation
  * that serves as the single source of truth for all Praxis applications.
  */

package/core/schema-engine/psf.ts

@@ -1,9 +1,9 @@
 /**
  * Praxis Schema Format (PSF) Types
- * 
+ *
  * PSF is the canonical AST format that serves as the single source of truth.
  * All code, canvas, and documentation are derived from or synchronized with PSF.
- * 
+ *
  * Design principles:
  * - JSON-serializable for persistence and transmission
  * - Supports bidirectional code ↔ canvas sync
@@ -211,7 +211,16 @@ export type PSFFieldType =
  */
 export interface PSFValidation {
   /** Validation type */
-  type: 'required' | 'min' | 'max' | 'minLength' | 'maxLength' | 'pattern' | 'email' | 'url' | 'custom';
+  type:
+    | 'required'
+    | 'min'
+    | 'max'
+    | 'minLength'
+    | 'maxLength'
+    | 'pattern'
+    | 'email'
+    | 'url'
+    | 'custom';
   /** Validation value */
   value?: unknown;
   /** Error message */

package/core/schema-engine/types.ts

@@ -1,6 +1,6 @@
 /**
  * Schema Engine Types
- * 
+ *
  * Re-exports types from the schema engine for external use.
  */
 
@@ -49,15 +49,7 @@ export type {
 } from './compiler.js';
 
 // Generator Types
-export type {
-  GeneratorOptions,
-  GeneratedFile,
-  GenerationResult,
-} from './generator.js';
+export type { GeneratorOptions, GeneratedFile, GenerationResult } from './generator.js';
 
 // Validator Types
-export type {
-  ValidationResult,
-  ValidationError,
-  ValidationOptions,
-} from './validator.js';
+export type { ValidationResult, ValidationError, ValidationOptions } from './validator.js';

package/core/schema-engine/validator.ts

@@ -1,6 +1,6 @@
 /**
  * PSF Validator
- * 
+ *
  * Validates PSF schemas for correctness, completeness, and consistency.
  */
 
@@ -63,13 +63,49 @@ export interface ValidationOptions {
  * Reserved JavaScript keywords
  */
 const RESERVED_KEYWORDS = new Set([
-  'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger',
-  'default', 'delete', 'do', 'else', 'export', 'extends', 'finally',
-  'for', 'function', 'if', 'import', 'in', 'instanceof', 'new',
-  'return', 'super', 'switch', 'this', 'throw', 'try', 'typeof',
-  'var', 'void', 'while', 'with', 'yield', 'let', 'static',
-  'enum', 'await', 'implements', 'interface', 'package', 'private',
-  'protected', 'public',
+  'break',
+  'case',
+  'catch',
+  'class',
+  'const',
+  'continue',
+  'debugger',
+  'default',
+  'delete',
+  'do',
+  'else',
+  'export',
+  'extends',
+  'finally',
+  'for',
+  'function',
+  'if',
+  'import',
+  'in',
+  'instanceof',
+  'new',
+  'return',
+  'super',
+  'switch',
+  'this',
+  'throw',
+  'try',
+  'typeof',
+  'var',
+  'void',
+  'while',
+  'with',
+  'yield',
+  'let',
+  'static',
+  'enum',
+  'await',
+  'implements',
+  'interface',
+  'package',
+  'private',
+  'protected',
+  'public',
 ]);
 
 /**
@@ -176,7 +212,11 @@ export class PSFValidator {
       if (!fact.tag) {
         this.addError(`${path}.tag`, 'Fact tag is required', 'missing-tag');
       } else if (this.options.checkNaming && !this.isValidIdentifier(fact.tag)) {
-        this.addError(`${path}.tag`, `"${fact.tag}" is not a valid identifier`, 'invalid-identifier');
+        this.addError(
+          `${path}.tag`,
+          `"${fact.tag}" is not a valid identifier`,
+          'invalid-identifier'
+        );
       }
 
       if (!fact.payload) {
@@ -199,7 +239,11 @@ export class PSFValidator {
       if (!event.tag) {
         this.addError(`${path}.tag`, 'Event tag is required', 'missing-tag');
       } else if (this.options.checkNaming && !this.isValidIdentifier(event.tag)) {
-        this.addError(`${path}.tag`, `"${event.tag}" is not a valid identifier`, 'invalid-identifier');
+        this.addError(
+          `${path}.tag`,
+          `"${event.tag}" is not a valid identifier`,
+          'invalid-identifier'
+        );
       }
 
       if (!event.payload) {
@@ -222,7 +266,11 @@ export class PSFValidator {
       }
 
       if (!rule.description) {
-        this.addWarning(`${path}.description`, 'Rule description is recommended', 'missing-description');
+        this.addWarning(
+          `${path}.description`,
+          'Rule description is recommended',
+          'missing-description'
+        );
       }
 
       if (!rule.then) {
@@ -256,7 +304,11 @@ export class PSFValidator {
       }
 
       if (!constraint.description) {
-        this.addWarning(`${path}.description`, 'Constraint description is recommended', 'missing-description');
+        this.addWarning(
+          `${path}.description`,
+          'Constraint description is recommended',
+          'missing-description'
+        );
       }
 
       if (!constraint.check) {
@@ -264,7 +316,11 @@ export class PSFValidator {
       }
 
       if (!constraint.errorMessage) {
-        this.addWarning(`${path}.errorMessage`, 'Constraint error message is recommended', 'missing-error-message');
+        this.addWarning(
+          `${path}.errorMessage`,
+          'Constraint error message is recommended',
+          'missing-error-message'
+        );
       }
     });
   }
@@ -283,7 +339,11 @@ export class PSFValidator {
       if (!model.name) {
         this.addError(`${path}.name`, 'Model name is required', 'missing-name');
       } else if (this.options.checkNaming && !this.isValidTypeName(model.name)) {
-        this.addError(`${path}.name`, `"${model.name}" is not a valid type name (should be PascalCase)`, 'invalid-type-name');
+        this.addError(
+          `${path}.name`,
+          `"${model.name}" is not a valid type name (should be PascalCase)`,
+          'invalid-type-name'
+        );
       }
 
       if (!model.fields || model.fields.length === 0) {
@@ -297,7 +357,10 @@ export class PSFValidator {
   /**
    * Validate model fields
    */
-  private validateModelFields(fields: { name: string; type: PSFFieldType; optional?: boolean }[], basePath: string): void {
+  private validateModelFields(
+    fields: { name: string; type: PSFFieldType; optional?: boolean }[],
+    basePath: string
+  ): void {
     const fieldNames = new Set<string>();
 
     fields.forEach((field, index) => {
@@ -312,7 +375,11 @@ export class PSFValidator {
         fieldNames.add(field.name);
 
         if (this.options.checkNaming && !this.isValidPropertyName(field.name)) {
-          this.addWarning(`${path}.name`, `"${field.name}" should be camelCase`, 'naming-convention');
+          this.addWarning(
+            `${path}.name`,
+            `"${field.name}" should be camelCase`,
+            'naming-convention'
+          );
         }
       }
 
@@ -390,12 +457,20 @@ export class PSFValidator {
           if (step.next) {
             if (typeof step.next === 'string') {
               if (!stepIds.has(step.next)) {
-                this.addError(`${stepPath}.next`, `Step "${step.next}" does not exist`, 'invalid-step-reference');
+                this.addError(
+                  `${stepPath}.next`,
+                  `Step "${step.next}" does not exist`,
+                  'invalid-step-reference'
+                );
               }
             } else {
               Object.values(step.next).forEach((nextId) => {
                 if (!stepIds.has(nextId)) {
-                  this.addError(`${stepPath}.next`, `Step "${nextId}" does not exist`, 'invalid-step-reference');
+                  this.addError(
+                    `${stepPath}.next`,
+                    `Step "${nextId}" does not exist`,
+                    'invalid-step-reference'
+                  );
                 }
               });
             }
@@ -404,7 +479,11 @@ export class PSFValidator {
 
         // Check initial step
         if (flow.initial && !stepIds.has(flow.initial)) {
-          this.addError(`${path}.initial`, `Initial step "${flow.initial}" does not exist`, 'invalid-step-reference');
+          this.addError(
+            `${path}.initial`,
+            `Initial step "${flow.initial}" does not exist`,
+            'invalid-step-reference'
+          );
         }
       }
     });
@@ -470,11 +549,19 @@ export class PSFValidator {
   /**
    * Check field type for references
    */
-  private checkFieldTypeReferences(type: PSFFieldType, modelNames: Set<string>, path: string): void {
+  private checkFieldTypeReferences(
+    type: PSFFieldType,
+    modelNames: Set<string>,
+    path: string
+  ): void {
     if (typeof type === 'object') {
       if ('reference' in type) {
         if (!modelNames.has(type.reference)) {
-          this.addWarning(path, `Reference to unknown model "${type.reference}"`, 'unknown-reference');
+          this.addWarning(
+            path,
+            `Reference to unknown model "${type.reference}"`,
+            'unknown-reference'
+          );
         }
       } else if ('array' in type) {
         this.checkFieldTypeReferences(type.array, modelNames, path);
@@ -535,7 +622,10 @@ export function createPSFValidator(options?: ValidationOptions): PSFValidator {
 /**
  * Validate a PSF schema (convenience function)
  */
-export function validatePSFSchema(schema: PSFSchema, options?: ValidationOptions): ValidationResult {
+export function validatePSFSchema(
+  schema: PSFSchema,
+  options?: ValidationOptions
+): ValidationResult {
   const validator = new PSFValidator(options);
   return validator.validate(schema);
 }