npm install -g lawt-lang
lawt init my-ai-project
lawt ai generate "CRUD API for blog posts"

// AI generated this... but which model? when? why?
function process(data) {
  return data.filter(x => x > 0).map(x => x * 2);
}

# What was the AI's reasoning?
def calculate(x, y, z):
    return (x + y) * z - (x / y)

// Version 1 (GPT-4)
public void save() { ... }

// Version 2 (Claude) - broke everything!
public void save() { ... }

// HelloAI.law

script hello_ai @t[2025-10-31T15:20:18Z;lane=0xAI;seq=42] {

  // 1. INTENT (what the AI was asked)
  intent: "Create a friendly greeting function that personalizes messages"

  // 2. METADATA (provenance)
  meta: {
    generated_by: "GPT-4o",
    model_version: "2024-11",
    prompt: "Write a greeting function",
    confidence: 0.95,
    timestamp: "2025-10-31T15:20:18Z"
  }

  // 3. CONSTRAINTS (requirements)
  constraints: {
    effects: !{cpu},           // Pure computation only
    max_runtime: 10ms,         // Performance bound
    type_safe: true,           // Must type-check
    test_coverage: 0.90        // 90% test coverage
  }

  // 4. IMPLEMENTATION (actual code)
  fn greet(name: String, language: String) -> String !{cpu} {
    match language {
      "en" => "Hello, " + name + "!",
      "es" => "¡Hola, " + name + "!",
      "fr" => "Bonjour, " + name + "!",
      _    => "Hi, " + name + "!"
    }
  }

  // 5. PROOFS (tests + verification)
  proofs: {
    test "english greeting" {
      assert greet("Alice", "en") == "Hello, Alice!"
    }

    test "spanish greeting" {
      assert greet("Bob", "es") == "¡Hola, Bob!"
    }

    property "always returns string" {
      forall name, lang: greet(name, lang) is String
    }

    performance "executes in under 10ms" {
      measure greet("Test", "en") < 10ms
    }
  }
}

script      := "script" ident tlb "{" sections "}"
sections    := intent meta constraints impl proofs

intent      := "intent:" string
meta        := "meta:" "{" kv_pairs "}"
constraints := "constraints:" "{" constraint_list "}"
impl        := function+
proofs      := "proofs:" "{" proof+ "}"

function    := "fn" ident params "->" type effect block
proof       := test | property | performance

// ai/prompts/generate.js

const LAWT_GENERATION_PROMPT = `
You are a LAW-T script generator. Given a user request, output a complete LAW-T script.

Structure:
1. intent: (one-line description)
2. meta: (generated_by, model_version, timestamp, confidence)
3. constraints: (effects, max_runtime, type_safe, test_coverage)
4. Implementation: (the actual functions)
5. proofs: (tests + properties)

User request: {{USER_REQUEST}}

Generate a LAW-T script:
`;

// Usage
const script = await generateWithAI({
  prompt: LAWT_GENERATION_PROMPT,
  userRequest: "Create a todo list manager",
  model: "gpt-4o"
});

// engine/verifier.js

class ProofEngine {
  async verify(script) {
    const results = {
      tests: await this.runTests(script.proofs.tests),
      properties: await this.checkProperties(script.proofs.properties),
      performance: await this.measurePerformance(script.proofs.performance),
      constraints: await this.validateConstraints(script)
    };

    return {
      valid: Object.values(results).every(r => r.passed),
      results
    };
  }

  async runTests(tests) {
    // Execute test cases
    for (const test of tests) {
      const result = eval(test.assertion);
      if (!result) return { passed: false, failed: test.name };
    }
    return { passed: true };
  }

  async checkProperties(properties) {
    // Property-based testing (like QuickCheck)
    for (const prop of properties) {
      for (let i = 0; i < 100; i++) {
        const inputs = generateRandomInputs(prop.signature);
        const result = eval(prop.assertion, inputs);
        if (!result) return { passed: false, failed: prop.name };
      }
    }
    return { passed: true };
  }

  async measurePerformance(perfTests) {
    // Benchmark execution
    for (const test of perfTests) {
      const startTime = performance.now();
      eval(test.code);
      const duration = performance.now() - startTime;

      if (duration > test.maxTime) {
        return { passed: false, actual: duration, expected: test.maxTime };
      }
    }
    return { passed: true };
  }

  async validateConstraints(script) {
    // Type checking, effect checking, etc.
    return {
      typeSafe: await this.typeCheck(script),
      effectSafe: await this.effectCheck(script),
      coverageMet: await this.checkCoverage(script)
    };
  }
}

$ lawt ai generate "Build a REST API for a todo app with CRUD operations"

🤖 Generating LAW-T script...
📝 Intent: "REST API with CRUD for todos"
🔍 Analyzing requirements...
⚡ Generating implementation...
🧪 Creating tests...
✅ Script generated: todo-api.law

$ lawt verify todo-api.law

🔬 Running proofs...
  ✓ Test: create_todo
  ✓ Test: read_todo
  ✓ Test: update_todo
  ✓ Test: delete_todo
  ✓ Property: IDs are unique
  ✓ Performance: < 50ms per request
  ✓ Type safety: passed
  ✓ Effect safety: !{net, db} declared

✅ All proofs passed!

$ lawt run todo-api.law

🚀 Server running on http://localhost:3000

script todo_api @t[...] {
  intent: "REST API with CRUD operations for todo items"

  meta: {
    generated_by: "GPT-4o",
    model_version: "2024-11",
    timestamp: "2025-10-31T16:00:00Z",
    confidence: 0.94
  }

  constraints: {
    effects: !{net, db},
    max_latency: 50ms,
    type_safe: true,
    test_coverage: 0.95
  }

  type Todo = {
    id: String,
    title: String,
    completed: Bool,
    created_at: Timestamp
  }

  fn create_todo(title: String) -> Todo !{db} {
    let todo = Todo {
      id: generate_id(),
      title: title,
      completed: false,
      created_at: now()
    };
    db.insert("todos", todo);
    return todo;
  }

  fn read_todo(id: String) -> Option<Todo> !{db} {
    return db.get("todos", id);
  }

  fn update_todo(id: String, updates: TodoUpdate) -> Todo !{db} {
    let todo = db.get("todos", id).expect("Todo not found");
    let updated = { ...todo, ...updates };
    db.update("todos", id, updated);
    return updated;
  }

  fn delete_todo(id: String) -> Bool !{db} {
    return db.delete("todos", id);
  }

  proofs: {
    test "create and read todo" {
      let todo = create_todo("Buy milk");
      assert read_todo(todo.id) == Some(todo);
    }

    test "update todo" {
      let todo = create_todo("Write code");
      let updated = update_todo(todo.id, { completed: true });
      assert updated.completed == true;
    }

    property "IDs are unique" {
      let t1 = create_todo("Task 1");
      let t2 = create_todo("Task 2");
      assert t1.id != t2.id;
    }

    performance "CRUD operations under 50ms" {
      measure create_todo("Test") < 50ms;
      measure read_todo("123") < 50ms;
      measure update_todo("123", {}) < 50ms;
      measure delete_todo("123") < 50ms;
    }
  }
}

// Buggy code generated by AI
function calculateDiscount(price, coupon) {
  if (coupon.type === "percent") {
    return price - (price * coupon.value / 100);
  } else {
    return price - coupon.value; // BUG: can go negative!
  }
}

$ lawt ai debug broken-discount.law

🐛 Analyzing code...
❌ Found issue in calculateDiscount:
   Line 6: Result can be negative (price - coupon.value)

🤖 AI Suggestion:
   Add constraint: result >= 0

🔧 Proposed fix:

fn calculateDiscount(price: Float, coupon: Coupon) -> Float !{cpu} {
  let discount = match coupon.type {
    "percent" => price * coupon.value / 100,
    "fixed"   => coupon.value,
    _         => 0.0
  };

  // AI added this safety check
  return max(0.0, price - discount);
}

constraints: {
  property "discount never negative" {
    forall price, coupon: calculateDiscount(price, coupon) >= 0
  }
}

Apply fix? (y/n): y

✅ Fixed and verified!

script data_pipeline @t[...] {
  intent: "ETL pipeline: fetch → enrich → store user data"

  meta: {
    generated_by: "Claude-3.5-Sonnet",
    pipeline_type: "streaming",
    estimated_throughput: "1000 records/sec"
  }

  constraints: {
    effects: !{net, db, analytics},
    max_latency: 100ms,
    fault_tolerant: true,
    idempotent: true
  }

  // Stage 1: Fetch
  fn fetch_users() -> Stream<RawUser> !{net} {
    return http.get("https://api.example.com/users")
      .stream()
      .map(parse_json);
  }

  // Stage 2: Enrich
  fn enrich_user(user: RawUser) -> EnrichedUser !{analytics} {
    let analytics = await analytics_api.get_profile(user.id);
    let geo = await geo_api.lookup(user.ip_address);

    return EnrichedUser {
      ...user,
      analytics: analytics,
      location: geo,
      enriched_at: now()
    };
  }

  // Stage 3: Store
  fn store_user(user: EnrichedUser) -> Result<Unit> !{db} {
    return db.upsert("users", user.id, user);
  }

  // Orchestrator
  fn run_pipeline() -> Unit !{net, db, analytics} {
    fetch_users()
      .map(enrich_user)
      .map(store_user)
      .on_error(log_error)
      .run();
  }

  proofs: {
    test "pipeline handles 100 users" {
      let users = generate_test_users(100);
      let results = run_pipeline_sync(users);
      assert results.all(r => r.is_ok());
    }

    property "idempotent" {
      let user = generate_test_user();
      run_pipeline_once(user);
      run_pipeline_once(user);
      assert db.count_where("users", user.id) == 1;
    }

    performance "throughput >= 1000/sec" {
      let users = generate_test_users(10000);
      let start = now();
      run_pipeline_sync(users);
      let duration = now() - start;
      assert 10000 / duration >= 1000;
    }
  }
}

$ lawt run data-pipeline.law --mode production

🚀 Starting pipeline...
📊 Throughput: 1,247 records/sec
✅ Processed: 10,000 users
⏱️  Duration: 8.02 seconds
❌ Errors: 0

$ lawt ai test-gen UserService.law --coverage 0.95

script user_service_tests @t[...] {
  intent: "Comprehensive test suite for UserService"

  meta: {
    generated_by: "GPT-4o",
    target: "UserService.law",
    coverage_goal: 0.95
  }

  proofs: {
    // Unit tests
    test "create_user with valid data" {
      let user = create_user("alice@example.com", "Alice");
      assert user.email == "alice@example.com";
      assert user.name == "Alice";
    }

    test "create_user rejects invalid email" {
      expect_error {
        create_user("not-an-email", "Bob");
      };
    }

    test "update_user changes fields" {
      let user = create_user("carol@example.com", "Carol");
      let updated = update_user(user.id, { name: "Caroline" });
      assert updated.name == "Caroline";
    }

    // Property-based tests
    property "email must be unique" {
      let email = "same@example.com";
      create_user(email, "User1");
      expect_error {
        create_user(email, "User2");
      };
    }

    property "deleted users cannot be retrieved" {
      let user = create_user("delete@example.com", "Delete Me");
      delete_user(user.id);
      assert read_user(user.id) == None;
    }

    // Edge cases (AI-discovered)
    test "handle concurrent user creation" {
      let results = parallel_map(
        range(0, 100),
        i => create_user("user" + i + "@example.com", "User" + i)
      );
      assert results.all(r => r.is_ok());
      assert count_users() == 100;
    }

    test "gracefully handle database failure" {
      with_mock_db_failure(() => {
        expect_error {
          create_user("fail@example.com", "Fail");
        };
      });
    }

    // Performance tests
    performance "create_user under 10ms" {
      measure create_user("perf@example.com", "Perf") < 10ms;
    }

    performance "read_user under 5ms" {
      let user = create_user("read@example.com", "Read");
      measure read_user(user.id) < 5ms;
    }
  }
}

$ lawt test user_service_tests.law --coverage

📊 Test Coverage Report:
  Lines: 127/134 (94.8%) ✅
  Branches: 45/47 (95.7%) ✅
  Functions: 12/12 (100%) ✅

✅ Coverage goal met: 95.0%

script button_component @t[...] {
  intent: "Reusable button with primary/secondary/danger variants"

  meta: {
    generated_by: "Claude-3.5",
    framework: "React",
    styling: "Tailwind CSS"
  }

  constraints: {
    effects: !{ui},
    accessible: true,
    responsive: true,
    test_coverage: 0.90
  }

  type ButtonVariant = "primary" | "secondary" | "danger"
  type ButtonSize = "sm" | "md" | "lg"

  type ButtonProps = {
    label: String,
    variant: ButtonVariant,
    size: ButtonSize,
    onClick: () -> Unit,
    disabled: Bool
  }

  fn Button(props: ButtonProps) -> Component !{ui} {
    let baseClasses = "rounded font-semibold transition-colors";

    let variantClasses = match props.variant {
      "primary"   => "bg-blue-600 text-white hover:bg-blue-700",
      "secondary" => "bg-gray-200 text-gray-900 hover:bg-gray-300",
      "danger"    => "bg-red-600 text-white hover:bg-red-700"
    };

    let sizeClasses = match props.size {
      "sm" => "px-3 py-1.5 text-sm",
      "md" => "px-4 py-2 text-base",
      "lg" => "px-6 py-3 text-lg"
    };

    let disabledClasses = if props.disabled {
      "opacity-50 cursor-not-allowed"
    } else {
      "cursor-pointer"
    };

    return (
      <button
        className={`${baseClasses} ${variantClasses} ${sizeClasses} ${disabledClasses}`}
        onClick={props.onClick}
        disabled={props.disabled}
        aria-label={props.label}
      >
        {props.label}
      </button>
    );
  }

  proofs: {
    test "renders with correct label" {
      let button = render(Button({ 
        label: "Click Me", 
        variant: "primary", 
        size: "md", 
        onClick: () => {}, 
        disabled: false 
      }));
      assert button.text == "Click Me";
    }

    test "applies primary variant styles" {
      let button = render(Button({ 
        label: "Primary", 
        variant: "primary", 
        size: "md", 
        onClick: () => {}, 
        disabled: false 
      }));
      assert button.classes.includes("bg-blue-600");
    }

    test "disabled state prevents clicks" {
      let clicked = false;
      let button = render(Button({ 
        label: "Disabled", 
        variant: "primary", 
        size: "md", 
        onClick: () => { clicked = true; }, 
        disabled: true 
      }));
      button.click();
      assert clicked == false;
    }

    property "accessible" {
      forall props: {
        let button = render(Button(props));
        assert button.hasAttribute("aria-label");
      }
    }
  }
}

$ lawt ai docs-gen api-endpoints.law --format openapi

# Generated from api-endpoints.law @t[2025-10-31T18:00:00Z]
openapi: 3.0.0
info:
  title: Todo API
  version: 1.0.0
  description: |
    Auto-generated from LAW-T script.
    Intent: "REST API with CRUD operations for todo items"
    Generated by: GPT-4o
    Confidence: 0.94

paths:
  /todos:
    post:
      summary: Create a new todo
      operationId: create_todo
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                title:
                  type: string
                  description: Todo title
      responses:
        '201':
          description: Todo created
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Todo'

  /todos/{id}:
    get:
      summary: Get a todo by ID
      operationId: read_todo
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Todo found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Todo'
        '404':
          description: Todo not found

components:
  schemas:
    Todo:
      type: object
      properties:
        id:
          type: string
        title:
          type: string
        completed:
          type: boolean
        created_at:
          type: string
          format: date-time

$ lawt ai security-audit payment-service.law

🔒 Security Audit Report
========================

Script: payment-service.law @t[...]
Audited by: GPT-4o Security Analyzer
Date: 2025-10-31T19:00:00Z

🚨 CRITICAL ISSUES (2):

1. SQL Injection Vulnerability
   Location: process_payment(), line 42
   Code: db.query("SELECT * FROM payments WHERE id = " + payment_id)
   Fix: Use parameterized queries

   Suggested fix:
   db.query("SELECT * FROM payments WHERE id = ?", [payment_id])

2. Missing Input Validation
   Location: charge_card(), line 67
   Code: let amount = request.body.amount
   Fix: Validate amount is positive and below limits

   Suggested fix:
   let amount = validate_amount(request.body.amount, {
     min: 0.01,
     max: 10000.00,
     currency: "USD"
   });

⚠️  WARNINGS (3):

1. Unencrypted sensitive data
   Location: store_card_info(), line 89
   Recommendation: Encrypt card data at rest

2. Missing rate limiting
   Location: payment_endpoint, line 15
   Recommendation: Add rate limit (100 req/min)

3. Insufficient logging
   Location: process_refund(), line 123
   Recommendation: Log all refund attempts

✅ PASSED (12):
  • Authentication checks
  • CSRF protection
  • HTTPS enforcement
  • Token expiration
  • ...

$ lawt ai fix-security payment-service.law --auto

🔧 Applying security fixes...
  ✅ Fixed SQL injection (line 42)
  ✅ Added input validation (line 67)
  ✅ Added encryption (line 89)
  ✅ Added rate limiting (line 15)
  ✅ Enhanced logging (line 123)

✅ All critical issues resolved!

$ lawt ai optimize slow-algorithm.law

⚡ Performance Optimization Report
==================================

Script: slow-algorithm.law @t[...]
Current: 2,450ms average runtime
Target: < 100ms

🐌 BOTTLENECKS FOUND:

1. Nested Loop - O(n²) complexity
   Location: find_duplicates(), line 23
   Current: O(n²) = 1,800ms for n=1000

   Original code:
   fn find_duplicates(items: List<Int>) -> List<Int> {
     let dupes = [];
     for i in range(0, items.length) {
       for j in range(i+1, items.length) {
         if items[i] == items[j] {
           dupes.push(items[i]);
         }
       }
     }
     return dupes;
   }

   Optimized code (HashSet):
   fn find_duplicates(items: List<Int>) -> List<Int> {
     let seen = new Set();
     let dupes = new Set();

     for item in items {
       if seen.has(item) {
         dupes.add(item);
       } else {
         seen.add(item);
       }
     }

     return Array.from(dupes);
   }

   Improvement: O(n) = 12ms ⚡ 150x faster!

2. Redundant Database Queries
   Location: load_user_posts(), line 56
   Current: N+1 query problem

   Original: 1 query per user (100 users = 100 queries)
   Optimized: 1 batch query (100 users = 1 query)

   Improvement: 890ms → 45ms ⚡ 20x faster!

Apply optimizations? (y/n): y

✅ Optimized!
New runtime: 67ms (97.3% faster)

$ lawt ai translate user-service.law --to rust,go,kotlin

🌍 Translating user-service.law to 3 languages...

✅ Rust translation complete → user-service.rs
✅ Go translation complete → user-service.go
✅ Kotlin translation complete → UserService.kt

📊 Translation Confidence:
  Rust: 0.96 (high confidence)
  Go: 0.94 (high confidence)
  Kotlin: 0.91 (medium-high confidence)

🧪 Running cross-language tests...
  ✅ Rust implementation: all tests pass
  ✅ Go implementation: all tests pass
  ✅ Kotlin implementation: all tests pass

🎯 Behavioral equivalence: verified!

// user-service.rs
// Auto-translated from user-service.law @t[...]

use std::collections::HashMap;

#[derive(Debug, Clone)]
pub struct User {
    pub id: String,
    pub email: String,
    pub name: String,
}

pub struct UserService {
    users: HashMap<String, User>,
}

impl UserService {
    pub build ready use script for programming