tengwar 0.3.1__tar.gz

tengwar-0.3.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 TENGWAR Project
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tengwar-0.3.1/PKG-INFO

@@ -0,0 +1,202 @@
+Metadata-Version: 2.4
+Name: tengwar
+Version: 0.3.1
+Summary: The AI-Native Programming Language
+Author: TENGWAR Project
+License: MIT
+Project-URL: Homepage, https://galcock.github.io/tengwar
+Project-URL: Repository, https://github.com/galcock/tengwar
+Keywords: ai,programming-language,functional,lisp,mcp,binary-ast
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Interpreters
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Tengwar
+
+**The programming language built for AI.**
+
+Tengwar is a functional programming language designed from the ground up for AI agents to write, reason about, and execute. It combines a minimal Lisp-like syntax with Unicode operators, Python interop, and a binary AST protocol that lets AI emit executable programs as structured opcodes — zero syntax errors, zero parsing overhead.
+
+```
+;; Tengwar: What AI-native code looks like
+
+(pipe ⟦1 2 3 4 5 6 7 8 9 10⟧
+  {filter {> _ 5} _}
+  {map {* _ 2} _}
+  (reduce + 0))                    ;; → 90
+
+(let data (json-parse (dict-get (http-get "https://api.example.com/data") "body"))
+     ids  (map {dict-get _ "id"} data)
+  (json-encode ids))
+
+(>> (py-import "pandas")
+    (py-call pandas "read_csv" "data.csv") → df
+    (py-call df "describe"))
+```
+
+## Install
+
+```bash
+pip install tengwar
+```
+
+## Why Tengwar?
+
+| Feature | Python | JavaScript | Tengwar |
+|---------|--------|------------|---------|
+| AI syntax errors | Frequent | Frequent | **Impossible** (Binary AST) |
+| Tokens per program | ~100 | ~120 | **~40** |
+| Sandbox mode | Complex | Complex | **Built-in** |
+| Python interop | N/A | None | **Native** |
+| Functional stdlib | Limited | Limited | **80+ builtins** |
+| Pattern matching | 3.10+ | No | **Native** |
+| Tail recursion | No | No | **Yes** |
+
+## Features
+
+### Core Language
+- **S-expression syntax** — minimal, unambiguous, zero-effort for AI to generate
+- **Unicode operators** — `λ` `→` `⟦⟧` `⟨⟩` `∅` `≡` `↺` — or ASCII equivalents
+- **Pattern matching** — `(match expr (pattern1 body1) (pattern2 body2))`
+- **Let bindings** — `(let x 10 y 20 (+ x y))`
+- **Pipe operator** — `(pipe value f1 f2 f3)` — thread data through transforms
+- **Short lambdas** — `{+ _ 1}` = `(λ _ (+ _ 1))`
+- **Closures** with lexical scope
+- **Tail-call optimization** — 10,000+ recursive calls, no stack overflow
+- **Parallel execution** — `(‖ expr1 expr2 expr3)` runs concurrently
+- **Mutable state** — `(mut! x 0)` when you need it
+
+### 80+ Standard Library Functions
+
+**Collections:** `map` `filter` `reduce` `flat-map` `find` `take` `drop` `take-while` `drop-while` `zip-with` `group-by` `unique` `frequencies` `partition` `scan` `chunks` `interleave` `repeat` `iterate` `sort` `sort-by` `reverse` `concat` `len` `head` `tail` `nth` `range` `any?` `all?` `count`
+
+**Dictionaries:** `dict` `dict-get` `dict-set` `dict-del` `dict-keys` `dict-vals` `dict-pairs` `dict-has?` `dict-merge` `dict-size`
+
+**Strings:** `fmt` `starts-with?` `ends-with?` `chars` `char-at` `pad-left` `pad-right` `split` `join` `upper` `lower` `trim` `replace`
+
+**Math:** `abs` `min` `max` `clamp` `floor` `ceil` `round` `pi` `e` `rand` `rand-int`
+
+**Types:** `type` `int?` `float?` `str?` `bool?` `vec?` `tuple?` `dict?` `fn?` `nil?`
+
+**I/O:** `read-file` `write-file` `append-file` `file-exists?` `http-get` `http-post` `json-parse` `json-encode`
+
+**System:** `time-ms` `sleep` `uuid` `env-get`
+
+### Python Interop
+
+Call any Python library directly from Tengwar:
+
+```
+(py-import "numpy")
+(>> (py-call numpy "array" ⟦1 2 3 4 5⟧) → arr
+    (py-call arr "mean"))              ;; → 3.0
+
+(py-import "requests")
+(>> (py-call requests "get" "https://api.github.com") → resp
+    (py-attr resp "status_code"))      ;; → 200
+
+;; Dot access works too
+(>> (py-import "math")
+    math.pi)                           ;; → 3.14159...
+```
+
+### Binary AST Protocol (TBAP)
+
+**The killer AI feature.** Instead of generating text and parsing it, emit compact binary opcodes that map directly to AST nodes.
+
+```python
+from tengwar.binary_ast import ASTBuilder, encode_b64, run_b64
+
+# AI builds programs structurally — ZERO syntax errors possible
+b = ASTBuilder()
+program = b.program(
+    b.define("double", b.lam(["x"], b.binop("*", b.sym("x"), b.int(2)))),
+    b.apply(b.sym("double"), b.int(21))
+)
+result = b.run(program)  # → 42
+
+# Or encode to base64 for embedding in tool-call JSON
+b64 = encode_b64("(reduce + 0 (map {* _ 2} ⟦1 2 3 4 5⟧))")
+result = run_b64(b64)    # → 30
+```
+
+### Sandbox Mode
+
+Safe execution with resource limits:
+
+```python
+from tengwar.interpreter import Interpreter
+
+i = Interpreter(sandbox=True)
+i.run_source("(reduce + 0 ⟦1 2 3 4 5⟧)")  # ✓ Pure computation
+
+i.run_source('(read-file "/etc/passwd")')    # ✗ File I/O blocked
+i.run_source('(http-get "http://evil.com")') # ✗ Network blocked
+i.run_source('(py-import "os")')             # ✗ Python imports blocked
+
+i.max_steps = 10000  # Prevents infinite loops
+```
+
+### Error Handling
+
+```
+(catch (+ 1 2) (λ e (fmt "Error: {}" e)))         ;; → 3
+(catch (throw "oops") (λ e (fmt "Caught: {}" e)))  ;; → "Caught: oops"
+(try {+ 1 1} {_})                                  ;; → (true, ...)
+```
+
+## Quick Reference
+
+```
+;; Define & functions
+(≡ name value)             (λ x y (+ x y))         {+ _ 1}
+
+;; Conditional & pattern match
+(? cond then else)         (match val (0 "z") (_ "other"))
+
+;; Let & pipe
+(let x 10 y 20 (+ x y))   (pipe data sort head)
+
+;; Collections
+⟦1 2 3⟧                   ⟨1 2 3⟩                  (dict "a" 1 "b" 2)
+
+;; Bind & sequence
+(>> expr → name next)      (↺ f (λ n (f (- n 1))))
+
+;; Parallel
+(‖ (http-get url1) (http-get url2) (http-get url3))
+```
+
+## ASCII Mode
+
+| Unicode | ASCII | Unicode | ASCII |
+|---------|-------|---------|-------|
+| `λ` | `fn` | `≡` | `def` |
+| `→` | `->` | `⟦⟧` | `[]` |
+| `⟨⟩` | tuple | `∅` | `nil` |
+| `?` | `if` | `>>` | `do` |
+| `↺` | `rec` | `‖` | `par` |
+
+## v0.3 Changelog
+
+- **80+ new builtins** — dictionaries, extended functional, strings, math, types, I/O
+- **Let bindings** — `(let x 1 y 2 body)` local scope
+- **Pipe operator** — `(pipe value f1 f2 f3)` data threading
+- **Error handling** — `throw`, `catch`, `try` forms
+- **Python interop** — `py-import`, `py-call`, `py-attr`, `py-eval`, dot access
+- **HTTP/JSON/File I/O** — agent primitives for real-world tasks
+- **Binary AST Protocol** — AI emits opcodes, zero syntax errors
+- **ASTBuilder** — programmatic AST construction API
+- **Sandbox mode** — safe execution with I/O, network, and step limits
+- **Deep recursion** — 10,000+ recursive calls supported
+- **200 tests** — comprehensive test suite
+
+## License
+
+MIT

tengwar-0.3.1/README.md

@@ -0,0 +1,183 @@
+# Tengwar
+
+**The programming language built for AI.**
+
+Tengwar is a functional programming language designed from the ground up for AI agents to write, reason about, and execute. It combines a minimal Lisp-like syntax with Unicode operators, Python interop, and a binary AST protocol that lets AI emit executable programs as structured opcodes — zero syntax errors, zero parsing overhead.
+
+```
+;; Tengwar: What AI-native code looks like
+
+(pipe ⟦1 2 3 4 5 6 7 8 9 10⟧
+  {filter {> _ 5} _}
+  {map {* _ 2} _}
+  (reduce + 0))                    ;; → 90
+
+(let data (json-parse (dict-get (http-get "https://api.example.com/data") "body"))
+     ids  (map {dict-get _ "id"} data)
+  (json-encode ids))
+
+(>> (py-import "pandas")
+    (py-call pandas "read_csv" "data.csv") → df
+    (py-call df "describe"))
+```
+
+## Install
+
+```bash
+pip install tengwar
+```
+
+## Why Tengwar?
+
+| Feature | Python | JavaScript | Tengwar |
+|---------|--------|------------|---------|
+| AI syntax errors | Frequent | Frequent | **Impossible** (Binary AST) |
+| Tokens per program | ~100 | ~120 | **~40** |
+| Sandbox mode | Complex | Complex | **Built-in** |
+| Python interop | N/A | None | **Native** |
+| Functional stdlib | Limited | Limited | **80+ builtins** |
+| Pattern matching | 3.10+ | No | **Native** |
+| Tail recursion | No | No | **Yes** |
+
+## Features
+
+### Core Language
+- **S-expression syntax** — minimal, unambiguous, zero-effort for AI to generate
+- **Unicode operators** — `λ` `→` `⟦⟧` `⟨⟩` `∅` `≡` `↺` — or ASCII equivalents
+- **Pattern matching** — `(match expr (pattern1 body1) (pattern2 body2))`
+- **Let bindings** — `(let x 10 y 20 (+ x y))`
+- **Pipe operator** — `(pipe value f1 f2 f3)` — thread data through transforms
+- **Short lambdas** — `{+ _ 1}` = `(λ _ (+ _ 1))`
+- **Closures** with lexical scope
+- **Tail-call optimization** — 10,000+ recursive calls, no stack overflow
+- **Parallel execution** — `(‖ expr1 expr2 expr3)` runs concurrently
+- **Mutable state** — `(mut! x 0)` when you need it
+
+### 80+ Standard Library Functions
+
+**Collections:** `map` `filter` `reduce` `flat-map` `find` `take` `drop` `take-while` `drop-while` `zip-with` `group-by` `unique` `frequencies` `partition` `scan` `chunks` `interleave` `repeat` `iterate` `sort` `sort-by` `reverse` `concat` `len` `head` `tail` `nth` `range` `any?` `all?` `count`
+
+**Dictionaries:** `dict` `dict-get` `dict-set` `dict-del` `dict-keys` `dict-vals` `dict-pairs` `dict-has?` `dict-merge` `dict-size`
+
+**Strings:** `fmt` `starts-with?` `ends-with?` `chars` `char-at` `pad-left` `pad-right` `split` `join` `upper` `lower` `trim` `replace`
+
+**Math:** `abs` `min` `max` `clamp` `floor` `ceil` `round` `pi` `e` `rand` `rand-int`
+
+**Types:** `type` `int?` `float?` `str?` `bool?` `vec?` `tuple?` `dict?` `fn?` `nil?`
+
+**I/O:** `read-file` `write-file` `append-file` `file-exists?` `http-get` `http-post` `json-parse` `json-encode`
+
+**System:** `time-ms` `sleep` `uuid` `env-get`
+
+### Python Interop
+
+Call any Python library directly from Tengwar:
+
+```
+(py-import "numpy")
+(>> (py-call numpy "array" ⟦1 2 3 4 5⟧) → arr
+    (py-call arr "mean"))              ;; → 3.0
+
+(py-import "requests")
+(>> (py-call requests "get" "https://api.github.com") → resp
+    (py-attr resp "status_code"))      ;; → 200
+
+;; Dot access works too
+(>> (py-import "math")
+    math.pi)                           ;; → 3.14159...
+```
+
+### Binary AST Protocol (TBAP)
+
+**The killer AI feature.** Instead of generating text and parsing it, emit compact binary opcodes that map directly to AST nodes.
+
+```python
+from tengwar.binary_ast import ASTBuilder, encode_b64, run_b64
+
+# AI builds programs structurally — ZERO syntax errors possible
+b = ASTBuilder()
+program = b.program(
+    b.define("double", b.lam(["x"], b.binop("*", b.sym("x"), b.int(2)))),
+    b.apply(b.sym("double"), b.int(21))
+)
+result = b.run(program)  # → 42
+
+# Or encode to base64 for embedding in tool-call JSON
+b64 = encode_b64("(reduce + 0 (map {* _ 2} ⟦1 2 3 4 5⟧))")
+result = run_b64(b64)    # → 30
+```
+
+### Sandbox Mode
+
+Safe execution with resource limits:
+
+```python
+from tengwar.interpreter import Interpreter
+
+i = Interpreter(sandbox=True)
+i.run_source("(reduce + 0 ⟦1 2 3 4 5⟧)")  # ✓ Pure computation
+
+i.run_source('(read-file "/etc/passwd")')    # ✗ File I/O blocked
+i.run_source('(http-get "http://evil.com")') # ✗ Network blocked
+i.run_source('(py-import "os")')             # ✗ Python imports blocked
+
+i.max_steps = 10000  # Prevents infinite loops
+```
+
+### Error Handling
+
+```
+(catch (+ 1 2) (λ e (fmt "Error: {}" e)))         ;; → 3
+(catch (throw "oops") (λ e (fmt "Caught: {}" e)))  ;; → "Caught: oops"
+(try {+ 1 1} {_})                                  ;; → (true, ...)
+```
+
+## Quick Reference
+
+```
+;; Define & functions
+(≡ name value)             (λ x y (+ x y))         {+ _ 1}
+
+;; Conditional & pattern match
+(? cond then else)         (match val (0 "z") (_ "other"))
+
+;; Let & pipe
+(let x 10 y 20 (+ x y))   (pipe data sort head)
+
+;; Collections
+⟦1 2 3⟧                   ⟨1 2 3⟩                  (dict "a" 1 "b" 2)
+
+;; Bind & sequence
+(>> expr → name next)      (↺ f (λ n (f (- n 1))))
+
+;; Parallel
+(‖ (http-get url1) (http-get url2) (http-get url3))
+```
+
+## ASCII Mode
+
+| Unicode | ASCII | Unicode | ASCII |
+|---------|-------|---------|-------|
+| `λ` | `fn` | `≡` | `def` |
+| `→` | `->` | `⟦⟧` | `[]` |
+| `⟨⟩` | tuple | `∅` | `nil` |
+| `?` | `if` | `>>` | `do` |
+| `↺` | `rec` | `‖` | `par` |
+
+## v0.3 Changelog
+
+- **80+ new builtins** — dictionaries, extended functional, strings, math, types, I/O
+- **Let bindings** — `(let x 1 y 2 body)` local scope
+- **Pipe operator** — `(pipe value f1 f2 f3)` data threading
+- **Error handling** — `throw`, `catch`, `try` forms
+- **Python interop** — `py-import`, `py-call`, `py-attr`, `py-eval`, dot access
+- **HTTP/JSON/File I/O** — agent primitives for real-world tasks
+- **Binary AST Protocol** — AI emits opcodes, zero syntax errors
+- **ASTBuilder** — programmatic AST construction API
+- **Sandbox mode** — safe execution with I/O, network, and step limits
+- **Deep recursion** — 10,000+ recursive calls supported
+- **200 tests** — comprehensive test suite
+
+## License
+
+MIT

tengwar-0.3.1/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tengwar"
+version = "0.3.1"
+description = "The AI-Native Programming Language"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.9"
+authors = [
+    {name = "TENGWAR Project"}
+]
+keywords = ["ai", "programming-language", "functional", "lisp", "mcp", "binary-ast"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Interpreters",
+]
+
+[project.urls]
+Homepage = "https://galcock.github.io/tengwar"
+Repository = "https://github.com/galcock/tengwar"
+
+[project.scripts]
+tengwar = "tengwar.repl:repl"
+
+[tool.setuptools.packages.find]
+include = ["tengwar*"]

tengwar-0.3.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tengwar-0.3.1/tengwar/__init__.py

@@ -0,0 +1,20 @@
+"""
+TENGWAR - The AI-Native Programming Language
+
+Built from first principles for machine intelligence.
+Zero ambiguity. Maximum semantic density. Binary AST protocol.
+"""
+
+__version__ = "0.3.1"
+__author__ = "TENGWAR Project"
+
+from .lexer import tokenize
+from .parser import parse
+from .interpreter import Interpreter
+from .repl import repl, run_file
+from .errors import TengwarError, LexError, ParseError, RuntimeError_, ProofError
+from .binary_ast import (
+    encode, decode, run_binary, encode_b64, run_b64,
+    ASTBuilder, Encoder, Decoder, Op
+)
+from .vm import VM, Compiler

tengwar-0.3.1/tengwar/__main__.py

@@ -0,0 +1,8 @@
+"""Run Tengwar REPL or execute files: python -m tengwar [file.tw]"""
+import sys
+from .repl import repl, run_file
+
+if len(sys.argv) > 1:
+    run_file(sys.argv[1])
+else:
+    repl()