@plures/praxis 0.2.1 → 1.0.1

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

@@ -0,0 +1,142 @@
+/**
+ * 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 () => {
+      const db = createInMemoryDB();
+      const adapter = await createUnumAdapter({ db });
+      
+      expect(adapter).toBeDefined();
+      expect(adapter.identity).toBeNull();
+    });
+    
+    it("should create an adapter with identity", async () => {
+      const db = createInMemoryDB();
+      const adapter = await createUnumAdapter({
+        db,
+        identity: {
+          id: "test-user",
+          name: "Test User",
+          createdAt: Date.now(),
+        },
+      });
+      
+      expect(adapter.identity).toBeDefined();
+      expect(adapter.identity?.name).toBe("Test User");
+    });
+    
+    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");
+      expect(identity.id).toBeDefined();
+      expect(identity.createdAt).toBeDefined();
+    });
+    
+    it("should get identity by ID", async () => {
+      const db = createInMemoryDB();
+      const adapter = await createUnumAdapter({ db });
+      
+      const created = await adapter.setIdentity({ name: "Test" });
+      const fetched = await adapter.getIdentity(created.id);
+      
+      expect(fetched).toBeDefined();
+      expect(fetched?.name).toBe("Test");
+    });
+    
+    it("should create a channel", async () => {
+      const db = createInMemoryDB();
+      const adapter = await createUnumAdapter({ db });
+      
+      const channel = await adapter.createChannel("test-channel");
+      
+      expect(channel).toBeDefined();
+      expect(channel.name).toBe("test-channel");
+      expect(channel.id).toBeDefined();
+    });
+    
+    it("should join a channel", async () => {
+      const db = createInMemoryDB();
+      const adapter = await createUnumAdapter({ db });
+      
+      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");
+    });
+    
+    it("should list channels", async () => {
+      const db = createInMemoryDB();
+      const adapter = await createUnumAdapter({ db });
+      
+      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 () => {
+      const db = createInMemoryDB();
+      const adapter = await createUnumAdapter({
+        db,
+        identity: { id: "user-1", name: "User 1", createdAt: Date.now() },
+      });
+      
+      const channel = await adapter.createChannel("test-channel");
+      
+      const messages: unknown[] = [];
+      channel.subscribe((msg) => messages.push(msg));
+      
+      await channel.publish({
+        id: "msg-1",
+        sender: adapter.identity!,
+        content: { text: "Hello!" },
+        type: "text",
+      });
+      
+      expect(messages.length).toBe(1);
+    });
+    
+    it("should disconnect and cleanup", async () => {
+      const db = createInMemoryDB();
+      const adapter = await createUnumAdapter({ db });
+      
+      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 () => {
+      const db = createInMemoryDB();
+      const adapter = await createUnumAdapter({ db });
+      const registry = new PraxisRegistry();
+      const engine = createPraxisEngine({
+        initialContext: {},
+        registry,
+      });
+      
+      const cleanup = attachUnumToEngine(engine, adapter, "test-channel");
+      
+      expect(cleanup).toBeInstanceOf(Function);
+      cleanup();
+    });
+  });
+});

package/src/cli/commands/build.ts

@@ -0,0 +1,203 @@
+/**
+ * Build Command
+ * 
+ * Builds a Praxis application for production.
+ */
+
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Build options
+ */
+export interface BuildOptions {
+  /** Output directory */
+  output?: string;
+  /** Build target */
+  target?: 'web' | 'desktop' | 'mobile';
+  /** Minify output */
+  minify?: boolean;
+  /** Generate source maps */
+  sourcemap?: boolean;
+}
+
+/**
+ * Build application for production
+ */
+export async function build(options: BuildOptions): Promise<void> {
+  const output = options.output || './dist';
+  const target = options.target || 'web';
+  
+  console.log('\n╔═══════════════════════════════════════════════════╗');
+  console.log('║   Praxis Production Build                         ║');
+  console.log('╚═══════════════════════════════════════════════════╝\n');
+  
+  // Check if we're in a Praxis project
+  const packageJsonPath = path.join(process.cwd(), 'package.json');
+  
+  if (!fs.existsSync(packageJsonPath)) {
+    console.error('Error: No package.json found in current directory.');
+    console.log('Make sure you are in a Praxis project directory.\n');
+    process.exit(1);
+  }
+  
+  // Read package.json to check for build script
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+  
+  if (!packageJson.scripts?.build) {
+    console.error('Error: No "build" script found in package.json.');
+    console.log('\nTo build your Praxis project, add a build script to your package.json:');
+    console.log('  "scripts": {');
+    console.log('    "build": "vite build"');
+    console.log('  }\n');
+    process.exit(1);
+  }
+  
+  console.log(`Building for: ${target}`);
+  console.log(`Output: ${output}`);
+  console.log('');
+  
+  // Handle different build targets
+  if (target === 'desktop') {
+    await buildDesktop(options);
+    return;
+  }
+  
+  if (target === 'mobile') {
+    await buildMobile(options);
+    return;
+  }
+  
+  // Web build (default)
+  await buildWeb(options);
+}
+
+/**
+ * Build for web
+ */
+async function buildWeb(options: BuildOptions): Promise<void> {
+  const output = options.output || './dist';
+  
+  console.log('🌐 Building web application...\n');
+  
+  // Set up environment variables for Vite
+  const env = {
+    ...process.env,
+    FORCE_COLOR: '1',
+  };
+  
+  // Build args
+  const args = ['run', 'build'];
+  if (output !== './dist') {
+    args.push('--', '--outDir', output);
+  }
+  
+  return new Promise((resolve, reject) => {
+    const child = spawn('npm', args, {
+      stdio: 'inherit',
+      shell: true,
+      cwd: process.cwd(),
+      env,
+    });
+    
+    child.on('error', (error) => {
+      console.error('Build failed:', error.message);
+      reject(error);
+    });
+    
+    child.on('exit', (code) => {
+      if (code === 0) {
+        console.log('\n✅ Build completed successfully!');
+        console.log(`\nOutput: ${output}/`);
+        console.log('\nTo preview the build:');
+        console.log('  npm run preview\n');
+        resolve();
+      } else {
+        console.error(`\n❌ Build failed with code ${code}`);
+        process.exit(code || 1);
+      }
+    });
+  });
+}
+
+/**
+ * Build for desktop (Tauri)
+ */
+async function buildDesktop(_options: BuildOptions): Promise<void> {
+  console.log('🖥️  Building desktop application with Tauri...\n');
+  
+  // Check if Tauri is configured
+  const tauriConfigPath = path.join(process.cwd(), 'src-tauri', 'tauri.conf.json');
+  
+  if (!fs.existsSync(tauriConfigPath)) {
+    console.log('Tauri is not configured for this project.');
+    console.log('\nTo add Tauri support:');
+    console.log('  1. npm install -D @tauri-apps/cli');
+    console.log('  2. npm run tauri init');
+    console.log('  3. praxis build --target desktop\n');
+    console.log('For more information, see the Tauri integration docs.');
+    process.exit(1);
+  }
+  
+  // Check for tauri build script
+  const packageJson = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf-8'));
+  
+  const buildScript = packageJson.scripts?.['tauri:build'] || packageJson.scripts?.['tauri'];
+  
+  return new Promise((resolve, reject) => {
+    const child = spawn('npm', ['run', buildScript ? 'tauri:build' : 'tauri', 'build'], {
+      stdio: 'inherit',
+      shell: true,
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        FORCE_COLOR: '1',
+      },
+    });
+    
+    child.on('error', (error) => {
+      console.error('Desktop build failed:', error.message);
+      reject(error);
+    });
+    
+    child.on('exit', (code) => {
+      if (code === 0) {
+        console.log('\n✅ Desktop build completed!');
+        console.log('\nBundles are in: src-tauri/target/release/bundle/');
+        resolve();
+      } else {
+        console.error(`\n❌ Desktop build failed with code ${code}`);
+        process.exit(code || 1);
+      }
+    });
+  });
+}
+
+/**
+ * Build for mobile (Tauri mobile)
+ */
+async function buildMobile(_options: BuildOptions): Promise<void> {
+  console.log('📱 Building mobile application...\n');
+  
+  // Check if Tauri mobile is configured
+  const tauriConfigPath = path.join(process.cwd(), 'src-tauri', 'tauri.conf.json');
+  
+  if (!fs.existsSync(tauriConfigPath)) {
+    console.log('Tauri is not configured for this project.');
+    console.log('\nTo add mobile support:');
+    console.log('  1. npm install -D @tauri-apps/cli');
+    console.log('  2. npm run tauri init');
+    console.log('  3. npm run tauri android init');
+    console.log('  4. npm run tauri ios init');
+    console.log('  5. praxis build --target mobile\n');
+    console.log('For more information, see the Tauri mobile docs.');
+    process.exit(1);
+  }
+  
+  console.log('Mobile build requires platform-specific setup:');
+  console.log('\n📱 Android:');
+  console.log('  npm run tauri android build');
+  console.log('\n🍎 iOS:');
+  console.log('  npm run tauri ios build\n');
+}

package/src/cli/commands/canvas.ts

@@ -0,0 +1,246 @@
+/**
+ * Canvas Command
+ * 
+ * Opens the CodeCanvas visual schema editor.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as http from 'http';
+import {
+  schemaToCanvas,
+  canvasToYaml,
+  canvasToMermaid,
+  createCanvasEditor,
+} from '../../integrations/code-canvas.js';
+import { loadSchemaFromFile } from '../../core/schema/loader.js';
+import type { PraxisSchema } from '../../core/schema/types.js';
+
+/**
+ * Canvas command options
+ */
+export interface CanvasOptions {
+  /** Port for Canvas server */
+  port?: string;
+  /** Mode (edit, view, present) */
+  mode?: 'edit' | 'view' | 'present';
+  /** Export format */
+  export?: 'yaml' | 'mermaid' | 'json';
+  /** Output file for export */
+  output?: string;
+}
+
+/**
+ * Open CodeCanvas for visual editing
+ */
+export async function canvas(schemaPath: string | undefined, options: CanvasOptions): Promise<void> {
+  const port = parseInt(options.port || '3000', 10);
+  const mode = options.mode || 'edit';
+  
+  console.log('\n╔═══════════════════════════════════════════════════╗');
+  console.log('║   CodeCanvas Visual Editor                        ║');
+  console.log('╚═══════════════════════════════════════════════════╝\n');
+  
+  // If export format is specified, export and exit
+  if (options.export) {
+    await exportCanvas(schemaPath, options);
+    return;
+  }
+  
+  // Load schema if provided
+  let schema: PraxisSchema | undefined;
+  if (schemaPath && fs.existsSync(schemaPath)) {
+    try {
+      const result = await loadSchemaFromFile(schemaPath);
+      if (result.errors.length > 0) {
+        console.error(`Error loading schema: ${result.errors.join(', ')}`);
+        process.exit(1);
+      }
+      schema = result.schema;
+      console.log(`✓ Loaded schema: ${schemaPath}`);
+    } catch (error) {
+      console.error(`Error loading schema: ${error}`);
+      process.exit(1);
+    }
+  }
+  
+  // Create canvas from schema
+  const editor = createCanvasEditor({ schema, layout: 'hierarchical' });
+  
+  console.log(`\nStarting Canvas server on http://localhost:${port}`);
+  console.log(`Mode: ${mode}\n`);
+  
+  // Start a simple HTTP server for the canvas
+  const server = http.createServer((req, res) => {
+    if (req.url === '/') {
+      res.writeHead(200, { 'Content-Type': 'text/html' });
+      res.end(generateCanvasHtml(editor.document, mode));
+    } else if (req.url === '/api/canvas') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(editor.document));
+    } else if (req.url === '/api/mermaid') {
+      res.writeHead(200, { 'Content-Type': 'text/plain' });
+      res.end(editor.toMermaid());
+    } else if (req.url === '/api/yaml') {
+      res.writeHead(200, { 'Content-Type': 'text/yaml' });
+      res.end(editor.toYaml());
+    } else if (req.url === '/api/schema') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(editor.toSchema()));
+    } else {
+      res.writeHead(404);
+      res.end('Not found');
+    }
+  });
+  
+  server.listen(port, () => {
+    console.log('Canvas server running!');
+    console.log(`\n  Local:   http://localhost:${port}`);
+    console.log(`  Mermaid: http://localhost:${port}/api/mermaid`);
+    console.log(`  YAML:    http://localhost:${port}/api/yaml`);
+    console.log(`  Schema:  http://localhost:${port}/api/schema\n`);
+    console.log('Press Ctrl+C to stop.\n');
+  });
+  
+  // Handle shutdown
+  process.on('SIGINT', () => {
+    console.log('\nShutting down Canvas server...');
+    server.close();
+    process.exit(0);
+  });
+}
+
+/**
+ * Export canvas to file
+ */
+async function exportCanvas(schemaPath: string | undefined, options: CanvasOptions): Promise<void> {
+  if (!schemaPath || !fs.existsSync(schemaPath)) {
+    console.error('Error: Schema file required for export');
+    console.log('Usage: praxis canvas <schema-file> --export yaml --output schema.canvas.yaml');
+    process.exit(1);
+  }
+  
+  const result = await loadSchemaFromFile(schemaPath);
+  if (result.errors.length > 0 || !result.schema) {
+    console.error(`Error loading schema: ${result.errors.join(', ')}`);
+    process.exit(1);
+  }
+  const canvas = schemaToCanvas(result.schema);
+  
+  let output: string;
+  let ext: string;
+  
+  switch (options.export) {
+    case 'yaml':
+      output = canvasToYaml(canvas);
+      ext = 'yaml';
+      break;
+    case 'mermaid':
+      output = canvasToMermaid(canvas);
+      ext = 'mmd';
+      break;
+    case 'json':
+    default:
+      output = JSON.stringify(canvas, null, 2);
+      ext = 'json';
+  }
+  
+  const outputPath = options.output || `${path.basename(schemaPath, path.extname(schemaPath))}.canvas.${ext}`;
+  fs.writeFileSync(outputPath, output);
+  
+  console.log(`✓ Exported canvas to: ${outputPath}`);
+}
+
+/**
+ * Generate HTML for canvas viewer
+ */
+function generateCanvasHtml(document: ReturnType<typeof createCanvasEditor>['document'], mode: string): string {
+  const mermaidDiagram = canvasToMermaid({
+    id: document.id,
+    name: document.name,
+    version: document.version,
+    nodes: document.nodes,
+    edges: document.edges,
+  });
+  
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>CodeCanvas - ${document.name}</title>
+  <script src="https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.min.js"></script>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #1a1a2e; color: #eee; }
+    .header { background: #16213e; padding: 1rem 2rem; display: flex; justify-content: space-between; align-items: center; }
+    .header h1 { font-size: 1.25rem; color: #00d9ff; }
+    .header .mode { background: #0f3460; padding: 0.25rem 0.75rem; border-radius: 4px; font-size: 0.875rem; }
+    .main { padding: 2rem; display: flex; gap: 2rem; }
+    .canvas { flex: 1; background: #16213e; border-radius: 8px; padding: 1.5rem; min-height: 500px; }
+    .sidebar { width: 300px; }
+    .panel { background: #16213e; border-radius: 8px; padding: 1rem; margin-bottom: 1rem; }
+    .panel h3 { font-size: 0.875rem; color: #00d9ff; margin-bottom: 0.75rem; text-transform: uppercase; letter-spacing: 0.05em; }
+    .panel ul { list-style: none; }
+    .panel li { padding: 0.5rem 0; border-bottom: 1px solid #0f3460; font-size: 0.875rem; }
+    .panel li:last-child { border-bottom: none; }
+    .mermaid { background: #fff; border-radius: 8px; padding: 1rem; }
+    .stats { display: grid; grid-template-columns: repeat(2, 1fr); gap: 0.5rem; }
+    .stat { background: #0f3460; padding: 0.75rem; border-radius: 4px; text-align: center; }
+    .stat-value { font-size: 1.5rem; font-weight: bold; color: #00d9ff; }
+    .stat-label { font-size: 0.75rem; color: #888; }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <h1>🎨 CodeCanvas - ${document.name}</h1>
+    <span class="mode">${mode.toUpperCase()} MODE</span>
+  </div>
+  <div class="main">
+    <div class="canvas">
+      <div class="mermaid">
+${mermaidDiagram}
+      </div>
+    </div>
+    <div class="sidebar">
+      <div class="panel">
+        <h3>Statistics</h3>
+        <div class="stats">
+          <div class="stat">
+            <div class="stat-value">${document.nodes.filter(n => n.type === 'model').length}</div>
+            <div class="stat-label">Models</div>
+          </div>
+          <div class="stat">
+            <div class="stat-value">${document.nodes.filter(n => n.type === 'component').length}</div>
+            <div class="stat-label">Components</div>
+          </div>
+          <div class="stat">
+            <div class="stat-value">${document.nodes.filter(n => n.type === 'event').length}</div>
+            <div class="stat-label">Events</div>
+          </div>
+          <div class="stat">
+            <div class="stat-value">${document.nodes.filter(n => n.type === 'fact').length}</div>
+            <div class="stat-label">Facts</div>
+          </div>
+        </div>
+      </div>
+      <div class="panel">
+        <h3>Nodes</h3>
+        <ul>
+          ${document.nodes.map(n => `<li><strong>${n.type}:</strong> ${n.label}</li>`).join('\n          ')}
+        </ul>
+      </div>
+      <div class="panel">
+        <h3>Edges</h3>
+        <ul>
+          ${document.edges.length ? document.edges.map(e => `<li>${e.source} → ${e.target}</li>`).join('\n          ') : '<li>No edges</li>'}
+        </ul>
+      </div>
+    </div>
+  </div>
+  <script>
+    mermaid.initialize({ startOnLoad: true, theme: 'base' });
+  </script>
+</body>
+</html>`;
+}