Claude/wokelang ebnf grammar qoe vv (#8)

* Implement WokeLang interpreter in Rust

Complete implementation of WokeLang with:

Lexer (src/lexer/):
- Token definitions for all keywords, operators, literals
- Uses logos for fast tokenization
- Handles comments, strings with escapes, numbers

Parser (src/parser/):
- Recursive descent parser
- Full expression parsing with correct precedence
- All statement types: remember, when/otherwise, repeat, attempt safely
- Pattern matching with decide based on
- Emote tags, consent blocks, gratitude declarations

AST (src/ast/):
- Complete type definitions for all language constructs
- Spanned nodes for error reporting

Interpreter (src/interpreter/):
- Tree-walking interpreter
- Scoped environments for variables
- Built-in functions: print, len, toString, toInt
- Consent system with interactive prompts
- Pattern matching evaluation
- All operators (arithmetic, comparison, logical)

CLI (src/main.rs):
- woke <file.woke> - run program
- woke --tokenize <file> - show tokens
- woke --parse <file> - show AST

Examples:
- examples/hello.woke - feature showcase
- examples/demo.woke - runnable demo

* Add REPL, WASM compilation, and Zig FFI

REPL (src/repl.rs):
- Interactive command-line interface with rustyline
- Commands: :help, :quit, :clear, :reset, :load, :ast
- Expression evaluation with automatic result printing
- Start with `woke` or `woke --repl`

WASM Compilation (src/codegen/):
- Compile WokeLang to WebAssembly binary format
- Uses wasm-encoder for proper WASM generation
- Supports functions, expressions, loops, conditionals
- Pattern matching compilation
- CLI: `woke -c input.woke` outputs input.wasm

Zig FFI (src/ffi/, zig/, include/):
- C-compatible API for embedding WokeLang
- Interpreter lifecycle: woke_interpreter_new/free
- Code execution: woke_exec, woke_eval
- Value operations: type checking, conversion, creation
- Static library (libwokelang.a) and shared library (.so)
- C header (include/wokelang.h)
- Zig bindings (zig/wokelang.zig) with idiomatic wrapper
- Example Zig program and build.zig

Other:
- examples/math.woke - math functions for WASM demo
- Cargo.toml updated for cdylib/staticlib targets

* Add comprehensive documentation and wiki

Includes:
- Project roadmap (ROADMAP.md) with version timeline through v1.0
- Wiki home page with table of contents
- Getting Started guides: Installation, Hello World, Basic Syntax, REPL
- Language Guide: Functions, Control Flow, Error Handling, Variables/Types
- Core Concepts: Consent System, Gratitude, Emote Tags
- Reference: CLI, Built-in Functions, Keywords, Operators, Language Spec
- Internals: Architecture, Lexer, Parser, Interpreter, WASM, FFI
- Tutorial: Building a CLI app

* Implement Phase 2 Language Completeness features

- Add Result types (Okay/Oops) with pattern matching support
- Implement error propagation operator (?) for Result types
- Add pattern matching destructuring with guard clauses
- Implement module system with use/share keywords
- Add new builtins: isOkay, isOops, getOkay, getOops
- Update WASM compiler and FFI for new AST variants
- Add example programs for Result types and modules

* Add static type inference with Hindley-Milner style checker

- Implement TypeChecker module with type inference
- Support for basic types: Int, Float, String, Bool, Unit
- Support for compound types: Array, Result, Maybe, Function
- Implement unification algorithm for type constraints
- Add built-in function type handling
- Include comprehensive test suite for type checking

* Implement Phase 3 Worker System with message passing

- Add async worker module with thread-based execution
- Implement WorkerHandle, WorkerContext, WorkerPool
- Add message passing: WorkerMessage enum with Value, Stop, Ping, etc.
- Add cancellation tokens for task control
- New lexer tokens: send, receive, channel, await, cancel, from
- New AST nodes: SendMessage, ReceiveMessage, AwaitWorker, CancelWorker
- Update parser for new worker syntax
- Update interpreter with worker statement handling
- Update WASM codegen and typechecker for new statements
- Add worker tests (4 new tests)
- Add workers.woke example demonstrating worker system
- Update ROADMAP.md with Phase 2 completion status

* Implement Phase 3 Security: capability-based security and persistent consent storage

- Add CapabilityRegistry with support for FileRead, FileWrite, Execute, Network,
  Environment, Process, SystemInfo, Crypto, Clipboard, Notify capabilities
- Implement wildcard capability matching (e.g., file:read:* grants all file reads)
- Add audit logging for all capability requests, grants, denials, and revocations
- Create ConsentStore for persistent storage of consent decisions
- Support consent durations: Session, Day, Week, Forever, Once
- Add security.woke example demonstrating superpower declarations

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: hyperpolymath

examples/security.woke

@@ -0,0 +1,81 @@
+// Example: Capability-based Security (Superpowers) in WokeLang
+// Demonstrates permission requests and consent-driven operations
+
+thanks to {
+    "WokeLang" → "For security-first design";
+}
+
+// Define a superpower for file operations
+superpower fileAccess {
+    print("Requesting file access permission...");
+    // In a real implementation, this would trigger a consent dialog
+}
+
+// Define a superpower for network access
+superpower networkAccess {
+    print("Requesting network access permission...");
+}
+
+// Sensitive function that requires file read permission
+to readConfig() {
+    only if okay "file:read:/etc/config" {
+        print("Reading configuration file...");
+        // File reading would happen here
+        give back "config data";
+    }
+    give back "no permission";
+}
+
+// Sensitive function that requires network access
+to fetchData(url: String) {
+    only if okay "network:http" {
+        print("Fetching data from: " + url);
+        // Network fetch would happen here
+        give back "fetched data";
+    }
+    give back "no permission";
+}
+
+// Safe function with explicit consent block
+to processData() {
+    print("Processing data safely...");
+
+    // Only execute sensitive operations with explicit consent
+    only if okay "data:write" {
+        print("Writing processed results...");
+    }
+}
+
+to main() {
+    hello "Security & Superpowers Demo";
+
+    print("=== Consent-based Operations ===");
+    print("");
+
+    // Try to read config (requires permission)
+    print("1. Attempting to read config:");
+    remember config = readConfig();
+    print("   Result: " + config);
+
+    print("");
+
+    // Try to fetch data (requires permission)
+    print("2. Attempting network fetch:");
+    remember data = fetchData("https://api.example.com");
+    print("   Result: " + data);
+
+    print("");
+
+    // Process data with consent blocks
+    print("3. Processing with consent blocks:");
+    processData();
+
+    print("");
+    print("=== Superpower Declarations ===");
+
+    // Declare superpower usage
+    superpower fileAccess;
+    superpower networkAccess;
+
+    goodbye "Security demo complete!";
+}

examples/workers.woke

@@ -0,0 +1,55 @@
+// Example: Worker System in WokeLang
+// Demonstrates workers, message passing, and async operations
+
+thanks to {
+    "WokeLang" → "For concurrency support";
+}
+
+// Define a background worker
+worker counter {
+    remember i = 0;
+    repeat 5 times {
+        i = i + 1;
+        print("Counter: " + toString(i));
+    }
+}
+
+// Define a worker that processes data
+worker processor {
+    print("Processor started");
+    // In a full implementation, this would receive messages
+    print("Processor completed");
+}
+
+to main() {
+    hello "Testing Worker System";
+
+    print("=== Spawning Workers ===");
+
+    // Spawn a worker (currently runs synchronously)
+    spawn worker counter;
+
+    print("");
+    print("=== Message Passing ===");
+
+    // Send a message to a worker (placeholder for now)
+    send 42 to processor;
+    send "hello" to processor;
+
+    // Receive from a worker (placeholder for now)
+    receive from processor;
+
+    print("");
+    print("=== Worker Control ===");
+
+    // Spawn another worker
+    spawn worker processor;
+
+    // Await worker completion
+    await processor;
+
+    // Cancel a worker if needed
+    // cancel processor;
+
+    goodbye "Workers demonstration complete!";
+}