Metadata-Version: 2.4
Name: nekova-lang
Version: 1.9.1
Summary: NEKOVA - The AI-Native Programming Language by SYNEKCOT Tech
Author-email: Emmanuel King Christopher <emmanuelkingchristopher@gmail.com>
License-Expression: BUSL-1.1
Project-URL: Homepage, https://github.com/kinghenesey/NEKOVA
Project-URL: Repository, https://github.com/kinghenesey/NEKOVA
Project-URL: Bug Tracker, https://github.com/kinghenesey/NEKOVA/issues
Keywords: nekova,programming-language,ai,ai-native,synekcot,nigeria
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Operating System :: OS Independent
Classifier: Topic :: Software Development :: Interpreters
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Requires-Python: >=3.10
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: colorama>=0.4.0
Requires-Dist: python-dotenv>=0.19.0
Requires-Dist: requests>=2.27.0
Requires-Dist: flask>=2.0.0
Requires-Dist: google-genai>=2.0.0
Requires-Dist: anthropic>=0.20.0
Requires-Dist: openai>=1.0.0
Requires-Dist: edge-tts>=6.0.0
Requires-Dist: pyttsx3>=2.90
Requires-Dist: aiohttp>=3.9.0
Requires-Dist: tomli>=2.0.0; python_version < "3.11"
Dynamic: license-file

﻿<div align="center">

# NEKOVA Programming Language

### The AI-Native Programming Language by SYNEKCOT Tech

![Version](https://img.shields.io/badge/version-1.9.1-C41E0E?style=flat-square)
![PyPI](https://img.shields.io/pypi/v/nekova-lang?style=flat-square)
![Python](https://img.shields.io/badge/python-3.10+-blue?style=flat-square)
![License](https://img.shields.io/badge/license-MIT-green?style=flat-square)
![Tests](https://img.shields.io/badge/tests-1130%20passing-success?style=flat-square)

*"The first programming language where AI is syntax, not a library."*

[Install](#installation) · [Features](#features) · [Examples](#examples) · [CLI Reference](#cli-reference) · [Roadmap](#roadmap)

</div>

---

## What is NEKOVA?

**NEKOVA** means *"Connected Forge"* — from Latin *nectere* (to connect) and *kova* (to forge). Built by **SYNEKCOT Tech** in Nigeria, for the world.

NEKOVA is an **AI-native programming language** where `think` is syntax. AI isn't a library you import — it's part of the language itself. In one file you can write web routes, query a database, call an AI model, run sandboxed code, and define a class — with no boilerplate.

```nekova
# AI is just syntax
think "What should I build today?" as text

# Speak and listen — built in
speak "Hello, world!"
let command = listen "Say a command"

# Schedule tasks
every 5 s:
    think "Check for new emails" as text

# Run untrusted code safely
sandbox strict:
    let result = 1 + 1
    show result

show sandbox_result["safe"]
```

---

## Why NEKOVA?

> *"Because every other language makes you import AI as a library, and I believe if AI is the future of how we build software, it should be a keyword — not an afterthought."*
> — Emmanuel King Christopher, Founder of SYNEKCOT Tech and Sole Author of Nekova Programming Language

NEKOVA was born in Nigeria to prove that world-class programming languages can come from anywhere. **1130 tests. 20 development phases. One language.**

---

## Installation

### Option 1 — pip (recommended)

```bash
pip install nekova-lang
```

Add your AI key to a `.env` file in your project:

```env
# You only need ONE key — NEKOVA auto-detects it
GEMINI_API_KEY=your_key_here        # Free — aistudio.google.com
ANTHROPIC_API_KEY=your_key_here     # console.anthropic.com
OPENAI_API_KEY=your_key_here        # platform.openai.com
```

Run your first program:

```bash
nekova hello.nk
```

### Option 2 — Clone from GitHub

```bash
git clone https://github.com/kinghenesey/NEKOVA.git
cd NEKOVA
pip install -e .
```

### VS Code Extension

Search **"NEKOVA"** in the VS Code Extension Marketplace, or install directly:

```bash
ext install SYNEKCOTTech.nekova
```

---

## Features

### Core Language

```nekova
# Variables
let name = "Emmanuel"
let age  = 21

# Tasks (functions) with type hints
task add(a: int, b: int) -> int:
    return a + b

# Default parameters
task greet(name, greeting="Hello"):
    show greeting + " " + name

# Varargs
task total(*nums):
    return sum(nums)

# Generators
task count(n: int):
    let i = 0
    while i < n:
        yield i
        let i = i + 1

for x in count(5):
    show x
```

### Classes and Objects

```nekova
class Animal:
    name: str
    init(name: str):
        self.name = name
    func speak():
        return self.name + " says hello"

class Dog extends Animal:
    func fetch():
        return self.name + " fetches!"

let d = new Dog("Rex")
show d.speak()
show d.fetch()
```

### Decorators

```nekova
task log(fn):
    task wrapper(x):
        show "calling with " + str(x)
        return fn(x)
    return wrapper

@log
task double(n):
    return n * 2

show double(21)   # → calling with 21 \n 42
```

### Error Types

```nekova
error NetworkError:
    message str
    code    int = 500

try:
    raise NetworkError("timeout", 408)
catch e:
    show e["message"]   # → timeout
    show e["code"]      # → 408
```

### AI — Built In

```nekova
# Single line AI calls
think "Summarise this in 3 words" as text
think "Extract the names" as list
think "Is this positive?" as bool
think "Parse this data" as json

# Remember context across calls
remember "user" as "Emmanuel"
let name = recall "user"

# Streaming
stream think "Write a short story about Lagos" as text
```

### Speak, Listen, Imagine

```nekova
# Text-to-speech
speak "Your report is ready"

# Speech-to-text
let answer = listen "What city are you in?"

# AI image generation
let img = imagine "a futuristic Lagos skyline at sunset" as url
show img
```

### Scheduled Execution

```nekova
# Run every 10 seconds, 5 times
every 10 s 5 times:
    show "checking..."

# Run forever in background
every 1 m:
    think "Any breaking news?" as text
```

### Built-in Test Runner

```nekova
task add(a, b):
    return a + b

test "addition":
    expect add(1, 2) == 3
    expect add(0, 0) == 0
    expect add(-1, 1) == 0

test "strings":
    expect len("hello") == 5
    expect "hello"[0] == "h"
```

### Data Shapes

```nekova
shape User:
    name  str
    age   int
    email str = "unknown"

let u = User("Emmanuel", 21)
show u["name"]      # → Emmanuel
show u["__shape__"] # → User
```

### Sandbox — Safe Execution

```nekova
# Run untrusted code in isolation
sandbox strict:
    let x = 10 * 10
    show x              # prints 100

show sandbox_result["safe"]      # → true
show sandbox_result["duration"]  # → 0.001

# Programmatic sandbox API
let result = sandbox_run("show 42")
show result["output"]  # → 42
show result["safe"]    # → true
```

### Standard Library in NEKOVA

```nekova
# Math — written in NEKOVA
use math
show pi                     # → 3.141592653589793
show clamp(15, 0, 10)       # → 10
show factorial(10)          # → 3628800
show lerp(0, 100, 0.5)      # → 50.0

# String — written in NEKOVA
use string
show repeat("ha", 3)        # → hahaha
show pad_left("5", 4)       # → "   5"
show is_palindrome("racecar") # → true

# File — written in NEKOVA
use file
write("data.txt", "hello")
let content = read("data.txt")
show line_count("data.txt")

# Date — written in NEKOVA
use date
show today()                # → 2025-06-27
show day_of_week(today())   # → Friday
show add_days(today(), 7)   # → 2025-07-04
```

### Pattern Matching

```nekova
let status = 404

match status:
    when 200: show "OK"
    when 404: show "Not Found"
    when 500: show "Server Error"
```

### Web Routes

```nekova
route GET "/":
    think "Write a welcome message" as text

route POST "/api/chat":
    let msg = request["body"]["message"]
    think msg as text

serve port: 8080
```

### Generators and Lazy Sequences

```nekova
task fibonacci():
    let a = 0
    let b = 1
    while true:
        yield a
        let temp = b
        let b = a + b
        let a = temp

let count = 0
for n in fibonacci():
    show n
    let count = count + 1
    if count == 10:
        break
```

---


### Self-Hosting Blockers (Phase 19b)

All five blockers for writing NEKOVA in NEKOVA are now fixed:

```nekova
# 1. Dict subscript assignment
let tokens = {}
let tokens["IF"] = "keyword"
show tokens["IF"]   # → keyword

# 2. Hex literals
let mask = 0xFF
let color = 0xDEADBEEF

# 3. Scientific notation
let avogadro = 6.022e23
let epsilon  = 1e-9

# 4. Underscore separators
let million = 1_000_000
let pi_approx = 3.141_592

# 5. Range arms in match
let c = "k"
match c:
    when "a".."z": show "lowercase"
    when "A".."Z": show "uppercase"
    when "0".."9": show "digit"
```

## CLI Reference

```bash
# Run a file
nekova run app.nk

# Run in sandbox mode
nekova run app.nk --sandbox
nekova run app.nk --sandbox --sandbox-mode relaxed

# Watch for changes
nekova run app.nk --watch

# Start the REPL
nekova repl

# Format code
nekova fmt app.nk

# Check for errors
nekova check app.nk

# Create a new project
nekova new myproject
nekova new myproject --template web
nekova new myproject --template ai
nekova new myproject --template fullstack

# Package management
nekova install requests
nekova uninstall requests
nekova search "http client"
```

---

## Language Reference

### Keywords

| Category | Keywords |
|----------|----------|
| Control flow | `if` `else` `elif` `while` `for` `in` `return` `break` `continue` `match` `when` `yield` |
| Declarations | `task` `let` `use` `import` `class` `object` `error` `shape` |
| Exception | `try` `catch` `finally` `raise` `assert` `pass` |
| AI | `think` `remember` `recall` `forget` `imagine` `speak` `listen` |
| Scheduling | `every` |
| Testing | `test` `expect` |
| Watching | `watch` |
| Sandbox | `sandbox` `strict` `relaxed` |
| OOP | `init` `self` `new` `extends` `func` |
| Async | `async` `await` `stream` |
| Logic | `and` `or` `not` `is` `in` `not in` `is not` |

### Operators

| Operator | Description |
|----------|-------------|
| `+` `-` `*` `/` | Arithmetic |
| `//` | Floor division |
| `%` `**` | Modulo, power |
| `==` `!=` `<` `>` `<=` `>=` | Comparison |
| `in` `not in` | Membership |
| `is` `is not` | Identity |
| `and` `or` `not` | Logic |
| `@` | Decorator |
| `->` | Return type hint |
| `x if c else y` | Ternary |

---

## Roadmap

| Phase | Status | Description |
|-------|--------|-------------|
| 1–14 | ✅ | Core language, AI, classes, web, packages |
| 15 | ✅ | Stability — `in/not in`, `//`, `range()`, slicing, builtins |
| 16 | ✅ | Standout features — `speak`, `listen`, `every`, `test/expect`, `imagine`, `shape`, `watch` |
| 17 | ✅ | Power user layer — generators, decorators, error types, typed tasks, `class` keyword |
| 18 | ✅ | Standard library in NEKOVA — `math.nk`, `string.nk`, `file.nk`, `date.nk` |
| 19 | ✅ | NEKOVA Sandbox — isolated execution, resource limits, violation tracking |
| 19b | ✅ | Security fixes — 38 bugs fixed, self-hosting blockers cleared |
| 20 | 🔄 | **Self-Hosting begins** — NEKOVA lexer written in NEKOVA |
| 21 | 🔜 | Prompt blocks, retry/fallback, enforced types |
| 22 | 🔜 | Observe blocks, mock think, pipe operator |
| 23 | 🔜 | Polish — inline errors, destructuring, docstrings |
| 24 | 🔜 | NEKOVA parser in NEKOVA — v2.0 milestone |
| 27 | 🎯 | Full self-hosting — interpreter in NEKOVA — v3.0 |

---

## About

**SYNEKCOT Tech** is a technology company founded by Emmanuel King Christopher (age 21) in Nigeria, building tools that empower developers across Africa and the world.

NEKOVA's source is publicly available and built entirely in public — every commit, every test, every phase, documented and shipped. NEKOVA is licensed under the [Business Source License 1.1](LICENSE): free to use, modify, and build on for personal projects, learning, and commercial products under $1M/year in revenue. The license converts automatically to Apache 2.0 four years after each release. See [LICENSE](LICENSE) for full terms, or the [Licensing FAQ](LICENSING_FAQ.md) for a plain-English explanation.

- GitHub: [github.com/kinghenesey/NEKOVA](https://github.com/kinghenesey/NEKOVA)
- PyPI: [pypi.org/project/nekova-lang](https://pypi.org/project/nekova-lang)
- VS Code: Search "NEKOVA" in the marketplace

---

<div align="center">

Built with ❤️ in Nigeria by SYNEKCOT Tech

*"Connected Forge — NEKOVA"*

</div>
