@plures/praxis 1.1.0 → 1.1.2

package/src/core/reactive-engine.svelte.ts

@@ -1,65 +1,65 @@
-/**
- * Praxis Reactive Logic Engine
- * 
- * A Svelte 5 native implementation of the Praxis Logic Engine.
- * Uses Runes ($state, $derived, $effect) for fine-grained reactivity.
- */
-
-export interface ReactiveEngineOptions<TContext> {
-    initialContext: TContext;
-    initialFacts?: any[];
-    initialMeta?: Record<string, unknown>;
-}
-
-export class ReactiveLogicEngine<TContext extends object> {
-    // The single source of truth, reactive by default
-    // We use $state.raw for things that shouldn't be deeply reactive if needed,
-    // but for context we usually want deep reactivity.
-    state = $state<{
-        context: TContext;
-        facts: any[];
-        meta: Record<string, unknown>;
-    }>({
-        context: {} as TContext,
-        facts: [],
-        meta: {}
-    });
-
-    constructor(options: ReactiveEngineOptions<TContext>) {
-        this.state.context = options.initialContext;
-        this.state.facts = options.initialFacts ?? [];
-        this.state.meta = options.initialMeta ?? {};
-    }
-
-    /**
-     * Access the reactive context directly.
-     * Consumers can use this in $derived() or $effect().
-     */
-    get context() {
-        return this.state.context;
-    }
-
-    /**
-     * Access the reactive facts list.
-     */
-    get facts() {
-        return this.state.facts;
-    }
-
-    /**
-     * Apply a mutation to the state.
-     * This is the "Action" or "Rule" equivalent.
-     * 
-     * @param mutator A function that receives the state and modifies it.
-     */
-    apply(mutator: (state: { context: TContext; facts: any[]; meta: Record<string, unknown> }) => void) {
-        mutator(this.state);
-    }
-
-    /**
-     * Access the reactive meta.
-     */
-    get meta() {
-        return this.state.meta;
-    }
-}
+/**
+ * Praxis Reactive Logic Engine
+ * 
+ * A Svelte 5 native implementation of the Praxis Logic Engine.
+ * Uses Runes ($state, $derived, $effect) for fine-grained reactivity.
+ */
+
+export interface ReactiveEngineOptions<TContext> {
+    initialContext: TContext;
+    initialFacts?: any[];
+    initialMeta?: Record<string, unknown>;
+}
+
+export class ReactiveLogicEngine<TContext extends object> {
+    // The single source of truth, reactive by default
+    // We use $state.raw for things that shouldn't be deeply reactive if needed,
+    // but for context we usually want deep reactivity.
+    state: { context: TContext; facts: any[]; meta: Record<string, unknown> } = $state<{
+        context: TContext;
+        facts: any[];
+        meta: Record<string, unknown>;
+    }>({
+        context: {} as TContext,
+        facts: [],
+        meta: {}
+    });
+
+    constructor(options: ReactiveEngineOptions<TContext>) {
+        this.state.context = options.initialContext;
+        this.state.facts = options.initialFacts ?? [];
+        this.state.meta = options.initialMeta ?? {};
+    }
+
+    /**
+     * Access the reactive context directly.
+     * Consumers can use this in $derived() or $effect().
+     */
+    get context(): TContext {
+        return this.state.context;
+    }
+
+    /**
+     * Access the reactive facts list.
+     */
+    get facts(): any[] {
+        return this.state.facts;
+    }
+
+    /**
+     * Apply a mutation to the state.
+     * This is the "Action" or "Rule" equivalent.
+     * 
+     * @param mutator A function that receives the state and modifies it.
+     */
+    apply(mutator: (state: { context: TContext; facts: any[]; meta: Record<string, unknown> }) => void): void {
+        mutator(this.state);
+    }
+
+    /**
+     * Access the reactive meta.
+     */
+    get meta(): Record<string, unknown> {
+        return this.state.meta;
+    }
+}

package/src/core/reactive-engine.ts

@@ -1,67 +1,58 @@
-/**
- * Praxis Reactive Logic Engine
- * 
- * A Svelte 5 native implementation of the Praxis Logic Engine.
- * Uses Runes ($state, $derived, $effect) for fine-grained reactivity.
- */
-
-console.log("Reactive Engine Loaded");
-
-export interface ReactiveEngineOptions<TContext> {
-    initialContext: TContext;
-    initialFacts?: any[];
-    initialMeta?: Record<string, unknown>;
-}
-
-export class ReactiveLogicEngine<TContext extends object> {
-    // The single source of truth, reactive by default
-    // We use $state.raw for things that shouldn't be deeply reactive if needed,
-    // but for context we usually want deep reactivity.
-    state = $state<{
-        context: TContext;
-        facts: any[];
-        meta: Record<string, unknown>;
-    }>({
-        context: {} as TContext,
-        facts: [],
-        meta: {}
-    });
-
-    constructor(options: ReactiveEngineOptions<TContext>) {
-        this.state.context = options.initialContext;
-        this.state.facts = options.initialFacts ?? [];
-        this.state.meta = options.initialMeta ?? {};
-    }
-
-    /**
-     * Access the reactive context directly.
-     * Consumers can use this in $derived() or $effect().
-     */
-    get context() {
-        return this.state.context;
-    }
-
-    /**
-     * Access the reactive facts list.
-     */
-    get facts() {
-        return this.state.facts;
-    }
-
-    /**
-     * Apply a mutation to the state.
-     * This is the "Action" or "Rule" equivalent.
-     * 
-     * @param mutator A function that receives the state and modifies it.
-     */
-    apply(mutator: (state: { context: TContext; facts: any[]; meta: Record<string, unknown> }) => void) {
-        mutator(this.state);
-    }
-
-    /**
-     * Access the reactive meta.
-     */
-    get meta() {
-        return this.state.meta;
-    }
-}
+/**
+ * Praxis Reactive Logic Engine
+ * 
+ * A minimal TypeScript implementation of the Praxis Logic Engine.
+ * This variant avoids Svelte-specific reactivity primitives to remain framework-agnostic.
+ */
+
+export interface ReactiveEngineOptions<TContext> {
+    initialContext: TContext;
+    initialFacts?: any[];
+    initialMeta?: Record<string, unknown>;
+}
+
+export class ReactiveLogicEngine<TContext extends object> {
+    state: { context: TContext; facts: any[]; meta: Record<string, unknown> } = {
+        context: {} as TContext,
+        facts: [],
+        meta: {}
+    };
+
+    constructor(options: ReactiveEngineOptions<TContext>) {
+        this.state.context = options.initialContext;
+        this.state.facts = options.initialFacts ?? [];
+        this.state.meta = options.initialMeta ?? {};
+    }
+
+    /**
+     * Access the context directly.
+     * Framework-specific wrappers (e.g., Svelte runes) can build on top of this value.
+     */
+    get context() {
+        return this.state.context;
+    }
+
+    /**
+     * Access the facts list.
+     */
+    get facts() {
+        return this.state.facts;
+    }
+
+    /**
+     * Apply a mutation to the state.
+     * This is the "Action" or "Rule" equivalent.
+     * 
+     * @param mutator A function that receives the state and modifies it.
+     */
+    apply(mutator: (state: { context: TContext; facts: any[]; meta: Record<string, unknown> }) => void) {
+        mutator(this.state);
+    }
+
+    /**
+     * Access the metadata.
+     */
+    get meta() {
+        return this.state.meta;
+    }
+}

package/src/core/schema/loader.common.ts

@@ -1,150 +1,150 @@
-/**
- * Praxis Schema Loader (Common/Browser Compatible)
- *
- * Core schema loading and validation functions that don't depend on Node.js APIs.
- */
-
-import { load as yamlLoad } from 'js-yaml';
-import type { PraxisSchema, ValidationResult } from './types.js';
-import { validateSchema } from './types.js';
-
-/**
- * Loader options
- */
-export interface LoaderOptions {
-  /** Validate schema after loading */
-  validate?: boolean;
-  /** Base directory for resolving relative paths */
-  baseDir?: string;
-}
-
-/**
- * Loader result
- */
-export interface LoaderResult {
-  /** Loaded schema */
-  schema?: PraxisSchema;
-  /** Validation result */
-  validation?: ValidationResult;
-  /** Load errors */
-  errors: string[];
-}
-
-/**
- * Create a new empty schema
- */
-export function createSchema(name: string): PraxisSchema {
-  return {
-    version: '1.0.0',
-    name,
-    description: `Schema for ${name}`,
-    models: [],
-    components: [],
-    logic: [],
-  };
-}
-
-/**
- * Load schema from JSON string
- */
-export function loadSchemaFromJson(json: string, options: LoaderOptions = {}): LoaderResult {
-  const errors: string[] = [];
-
-  try {
-    const schema = JSON.parse(json) as PraxisSchema;
-
-    // Validate if requested
-    let validation: ValidationResult | undefined;
-    if (options.validate !== false) {
-      validation = validateSchema(schema);
-      if (!validation.valid) {
-        errors.push('Schema validation failed:');
-        validation.errors.forEach((error) => {
-          errors.push(`  ${error.path}: ${error.message}`);
-        });
-      }
-    }
-
-    return {
-      schema,
-      validation,
-      errors,
-    };
-  } catch (error) {
-    if (error instanceof Error) {
-      errors.push(`Failed to parse JSON: ${error.message}`);
-    } else {
-      errors.push('Failed to parse JSON: Unknown error');
-    }
-    return { errors };
-  }
-}
-
-/**
- * Load schema from YAML string
- */
-export function loadSchemaFromYaml(yaml: string, options: LoaderOptions = {}): LoaderResult {
-  const errors: string[] = [];
-
-  try {
-    const schema = yamlLoad(yaml) as PraxisSchema;
-
-    // Validate if requested
-    let validation: ValidationResult | undefined;
-    if (options.validate !== false) {
-      validation = validateSchema(schema);
-      if (!validation.valid) {
-        errors.push('Schema validation failed:');
-        validation.errors.forEach((error) => {
-          errors.push(`  ${error.path}: ${error.message}`);
-        });
-      }
-    }
-
-    return {
-      schema,
-      validation,
-      errors,
-    };
-  } catch (error) {
-    if (error instanceof Error) {
-      errors.push(`Failed to parse YAML: ${error.message}`);
-    } else {
-      errors.push('Failed to parse YAML: Unknown error');
-    }
-    return { errors };
-  }
-}
-
-/**
- * Validate that a loaded schema has required fields for generation
- */
-export function validateForGeneration(schema: PraxisSchema): ValidationResult {
-  const errors: string[] = [];
-
-  // Check for entities/models
-  if (!schema.models || schema.models.length === 0) {
-    errors.push('Schema must define at least one model for generation');
-  }
-
-  // Check that models have valid fields
-  schema.models?.forEach((model, index) => {
-    if (!model.fields || model.fields.length === 0) {
-      errors.push(`Model "${model.name}" at index ${index} must have at least one field`);
-    }
-
-    model.fields?.forEach((field, fieldIndex) => {
-      if (!field.name) {
-        errors.push(`Field at index ${fieldIndex} in model "${model.name}" must have a name`);
-      }
-      if (!field.type) {
-        errors.push(`Field "${field.name}" in model "${model.name}" must have a type`);
-      }
-    });
-  });
-
-  return {
-    valid: errors.length === 0,
-    errors: errors.map((message) => ({ path: 'schema', message })),
-  };
-}
+/**
+ * Praxis Schema Loader (Common/Browser Compatible)
+ *
+ * Core schema loading and validation functions that don't depend on Node.js APIs.
+ */
+
+import { load as yamlLoad } from 'js-yaml';
+import type { PraxisSchema, ValidationResult } from './types.js';
+import { validateSchema } from './types.js';
+
+/**
+ * Loader options
+ */
+export interface LoaderOptions {
+  /** Validate schema after loading */
+  validate?: boolean;
+  /** Base directory for resolving relative paths */
+  baseDir?: string;
+}
+
+/**
+ * Loader result
+ */
+export interface LoaderResult {
+  /** Loaded schema */
+  schema?: PraxisSchema;
+  /** Validation result */
+  validation?: ValidationResult;
+  /** Load errors */
+  errors: string[];
+}
+
+/**
+ * Create a new empty schema
+ */
+export function createSchema(name: string): PraxisSchema {
+  return {
+    version: '1.0.0',
+    name,
+    description: `Schema for ${name}`,
+    models: [],
+    components: [],
+    logic: [],
+  };
+}
+
+/**
+ * Load schema from JSON string
+ */
+export function loadSchemaFromJson(json: string, options: LoaderOptions = {}): LoaderResult {
+  const errors: string[] = [];
+
+  try {
+    const schema = JSON.parse(json) as PraxisSchema;
+
+    // Validate if requested
+    let validation: ValidationResult | undefined;
+    if (options.validate !== false) {
+      validation = validateSchema(schema);
+      if (!validation.valid) {
+        errors.push('Schema validation failed:');
+        validation.errors.forEach((error) => {
+          errors.push(`  ${error.path}: ${error.message}`);
+        });
+      }
+    }
+
+    return {
+      schema,
+      validation,
+      errors,
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      errors.push(`Failed to parse JSON: ${error.message}`);
+    } else {
+      errors.push('Failed to parse JSON: Unknown error');
+    }
+    return { errors };
+  }
+}
+
+/**
+ * Load schema from YAML string
+ */
+export function loadSchemaFromYaml(yaml: string, options: LoaderOptions = {}): LoaderResult {
+  const errors: string[] = [];
+
+  try {
+    const schema = yamlLoad(yaml) as PraxisSchema;
+
+    // Validate if requested
+    let validation: ValidationResult | undefined;
+    if (options.validate !== false) {
+      validation = validateSchema(schema);
+      if (!validation.valid) {
+        errors.push('Schema validation failed:');
+        validation.errors.forEach((error) => {
+          errors.push(`  ${error.path}: ${error.message}`);
+        });
+      }
+    }
+
+    return {
+      schema,
+      validation,
+      errors,
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      errors.push(`Failed to parse YAML: ${error.message}`);
+    } else {
+      errors.push('Failed to parse YAML: Unknown error');
+    }
+    return { errors };
+  }
+}
+
+/**
+ * Validate that a loaded schema has required fields for generation
+ */
+export function validateForGeneration(schema: PraxisSchema): ValidationResult {
+  const errors: string[] = [];
+
+  // Check for entities/models
+  if (!schema.models || schema.models.length === 0) {
+    errors.push('Schema must define at least one model for generation');
+  }
+
+  // Check that models have valid fields
+  schema.models?.forEach((model, index) => {
+    if (!model.fields || model.fields.length === 0) {
+      errors.push(`Model "${model.name}" at index ${index} must have at least one field`);
+    }
+
+    model.fields?.forEach((field, fieldIndex) => {
+      if (!field.name) {
+        errors.push(`Field at index ${fieldIndex} in model "${model.name}" must have a name`);
+      }
+      if (!field.type) {
+        errors.push(`Field "${field.name}" in model "${model.name}" must have a type`);
+      }
+    });
+  });
+
+  return {
+    valid: errors.length === 0,
+    errors: errors.map((message) => ({ path: 'schema', message })),
+  };
+}