Ovie — The Complete Book

seeAm "Hello from Ovie!"

mut name = "Developer"
fn greet(person) {
    seeAm "Hello, " + person + "!"
}
greet(name)

oviec run hello.ov
# Hello from Ovie!
# Hello, Developer!

ovie --version       # 2.3.0
oviec --self-check   # Full validation
ovie new my-project
oviec run my-project/src/main.ov

git clone https://github.com/southwarridev/ovie.git
cd ovie
make build
make install

name = "Ovie"        // immutable
mut counter = 0      // mutable
counter = counter + 1
seeAm counter        // 1

fn add(a: Number, b: Number) -> Number {
    return a + b
}
mut result = add(10, 20)
seeAm result  // 30

if x > 5 { seeAm "big" } else { seeAm "small" }

for i in 0..5 { seeAm i }

mut n = 0
while n < 3 { n = n + 1; seeAm n }

struct Person { name: String, age: Number }
enum Status { Active, Inactive }

mut p = Person { name: "Amina", age: 28 }
seeAm p.name  // Amina

use std::core::{Result}

fn divide(a: Number, b: Number) -> Result {
    if b == 0 { return Result.Err("Division by zero") }
    return Result.Ok(a / b)
}

mut r = divide(10, 2)
if r.is_ok() { seeAm r.unwrap() }  // 5

/// Add two numbers
/// # Parameters
/// - a: First number
/// - b: Second number
/// # Returns
/// Sum of a and b
/// # Examples
/// ```ovie
/// mut r = add(2, 3)  // 5
/// ```
export fn add(a: Number, b: Number) -> Number {
    return a + b
}
export struct Point { x: Number, y: Number }
// Private — not accessible outside this module
fn helper(n: Number) -> Number { return n * 2 }

use std::math::{sqrt, pow}
use std::io::{println}
use std::core::{Result, Option}
import "./utils.ov"

fn main() {
    mut d = sqrt(16.0)
    seeAm "sqrt(16) = " + d  // 4.0
}

[package]
name = "my-app"
version = "1.0.0"
[dependencies]
oba = { path = "./oba" }

ovie init my-package   # Create new package
ovie add some-lib      # Add dependency
ovie install           # Install all dependencies
ovie cache clear       # Force full rebuild

use std::core::{Result, Option, Vec, HashMap}

// Result — success or failure
fn divide(a: Number, b: Number) -> Result {
    if b == 0 { return Result.Err("Division by zero") }
    return Result.Ok(a / b)
}
mut r = divide(10, 2)
if r.is_ok() { seeAm r.unwrap() }  // 5

// Option — value or nothing
fn find_user(id: Number) -> Option {
    if id == 1 { return Option.Some("Alice") }
    return Option.None()
}
mut u = find_user(1)
if u.is_some() { seeAm u.unwrap() }  // Alice

// Vec — dynamic array
mut v = Vec.new()
v = Vec.push(v, 10)
v = Vec.push(v, 20)
seeAm Vec.length(v)  // 2

// HashMap — key-value store
mut map = HashMap.new()
map = HashMap.insert(map, "name", "Ovie")
seeAm HashMap.get(map, "name")  // Ovie

use std::math::{sqrt, pow, abs, floor, ceil, min, max}

seeAm sqrt(16.0)      // 4.0
seeAm pow(2.0, 10.0)  // 1024.0
seeAm abs(-42)        // 42
seeAm floor(3.7)      // 3.0
seeAm ceil(3.2)       // 4.0
seeAm min(5, 3)       // 3
seeAm max(5, 3)       // 5

use std::io::{println, print, read_line}

print("Enter your name: ")
mut name = read_line()
println("Hello, " + name + "!")

use std::fs::{read_file, write_file, file_exists, make_dir}

if file_exists("data.txt") {
    mut content = read_file("data.txt")
    seeAm content
} else {
    write_file("data.txt", "Hello from Ovie!")
}

make_dir("output")
write_file("output/result.txt", "Done!")

use std::time::{now, duration_ms}

mut start = now()
// ... do work ...
mut elapsed = duration_ms(start, now())
seeAm "Elapsed: " + elapsed + "ms"

use std::env::{get_var, args, hostname}

mut home = get_var("HOME")
mut host = hostname()
mut program_args = args()

seeAm "Running on: " + host
seeAm "HOME: " + home

use std::cli::{parse_args, flag_value}
use std::env::{args}

mut cli = parse_args(args())
mut output = flag_value(cli, "--output", "result.txt")
seeAm "Output file: " + output

use std::log::{info, warn, error, debug}

info("Server started on port 8080")
warn("Config file not found, using defaults")
error("Failed to connect to database")
debug("Processing item: " + item_id)

use std::testing::{assert_eq, assert_true, assert_false}

fn test_add() {
    assert_eq(add(2, 3), 5, "2 + 3 should equal 5")
    assert_true(add(0, 0) == 0, "0 + 0 should be 0")
    assert_false(add(1, 1) == 3, "1 + 1 should not be 3")
}

test_add()
seeAm "All tests passed"

use std::module::{load_module, resolve, kb_query}

// Load a module dynamically
mut mod = load_module("./plugins/my_plugin.ov")

// Query the knowledge base
mut types = kb_query({
    category: "TypeInformation",
    symbol_name: "add"
})

use std::aproko::{store_entry, get_type_info, kb_entry_new, export_json}

// Store analysis result
mut entry = kb_entry_new(
    "my_fn",
    "TypeInformation",
    "{\"returns\":\"Number\"}"
)
entry.symbol_name = "my_fn"
store_entry(entry)

// Query type info
mut info = get_type_info("my_fn")

// Export for AI/LLM consumption
export_json(".ovie/aproko/export.json")

oviec analyze my_program.ov
# [WARNING] Style: Variable 'x' is single-character (line 3)
# [ERROR] Security: Unsafe block without justification (line 12)
# [INFO] Performance: Loop could use early exit (line 20)

[analysis]
min_severity = "Warning"   # Info | Warning | Error | Critical

[categories]
syntax = true
logic = true
performance = true
security = true
correctness = true
style = false              # Disable style checks

# Query knowledge base
ovie aproko query --category TypeInformation --symbol add

# Export for AI/LLM consumption
ovie aproko export --output knowledge.json

# Check documentation completeness
ovie doc check

# Generate API docs
ovie doc --format html

use std::math::{sqrt}
use std::io::{println}

fn main() {
    println("Hello")
    // sqrt imported but unused — Aproko will flag this
}

my-app/
├── ovie.toml          # Project manifest
├── ovie.lock          # Dependency lock file
├── src/
│   ├── main.ov        # Entry point
│   ├── config.ov      # Configuration
│   └── handlers/
│       └── mod.ov
├── tests/
│   └── integration.ov
└── docs/api/          # Generated by ovie doc

use std::env::{get_var}

struct AppConfig {
    port: Number,
    db_path: String,
    log_level: String,
}

fn load_config() -> AppConfig {
    return AppConfig {
        port: string_to_number(get_var("PORT")),
        db_path: get_var("DB_PATH"),
        log_level: get_var("LOG_LEVEL"),
    }
}

use std::core::{Result}
use std::log::{info, error}

fn process_request(id: String, data: String) -> Result {
    info("Processing: " + id)
    mut result = handle(data)
    if result.is_err() {
        error("Failed: " + id + " — " + result.unwrap_err())
        return result
    }
    info("Complete: " + id)
    return result
}

ovie test
oviec analyze src/main.ov
ovie doc check
oviec --self-check
oviec build --backend wasm src/main.ov

use std::testing::{assert_eq, assert_true}

fn add(a: Number, b: Number) -> Number { return a + b }

fn test_add_positive() {
    assert_eq(add(2, 3), 5, "2 + 3 = 5")
    assert_eq(add(0, 0), 0, "0 + 0 = 0")
}

fn test_add_negative() {
    assert_eq(add(-1, 1), 0, "-1 + 1 = 0")
}

test_add_positive()
test_add_negative()
seeAm "All tests passed"

ovie test

use std::testing::{assert_true}

// Property: add is commutative
fn prop_add_commutative(a: Number, b: Number) -> Boolean {
    return add(a, b) == add(b, a)
}

// Test with many values
mut i = -50
while i <= 50 {
    mut j = -50
    while j <= 50 {
        assert_true(prop_add_commutative(i, j), "add must be commutative")
        j = j + 1
    }
    i = i + 1
}
seeAm "Commutativity property holds"

use std::fs::{write_file, read_file, file_exists}
use std::testing::{assert_eq, assert_true}

fn test_file_roundtrip() {
    mut path = "/tmp/test_ovie.txt"
    mut content = "Hello from Ovie!"
    write_file(path, content)
    assert_true(file_exists(path), "File should exist after write")
    mut read_back = read_file(path)
    assert_eq(read_back, content, "Read content should match written content")
}

test_file_roundtrip()

use std::time::{now, duration_ms}

fn benchmark(label: String, iterations: Number, work: Function) {
    mut start = now()
    mut i = 0
    while i < iterations {
        work()
        i = i + 1
    }
    mut elapsed = duration_ms(start, now())
    seeAm label + ": " + elapsed + "ms for " + iterations + " iterations"
}

// Slow: creates new string on every iteration
fn build_slow(n: Number) -> String {
    mut result = ""
    mut i = 0
    while i < n {
        result = result + number_to_string(i) + ","
        i = i + 1
    }
    return result
}

// Better: collect into array, join once
fn build_fast(n: Number) -> String {
    mut parts = []
    mut i = 0
    while i < n {
        parts = array_push(parts, number_to_string(i))
        i = i + 1
    }
    return array_join(parts, ",")
}

use std::core::{HashMap}

// O(1) average — use HashMap for repeated lookups
fn build_lookup(items: Array) -> HashMap {
    mut map = HashMap.new()
    mut i = 0
    while i < array_length(items) {
        map = HashMap.insert(map, array_get(items, i), true)
        i = i + 1
    }
    return map
}

oviec build --backend wasm src/main.ov

ovie test
oviec analyze src/main.ov
ovie doc check
oviec --self-check
oviec build --backend wasm src/main.ov -o dist/app.wasm
oviec build-package  # Creates platform packages in target/dist/

# Disconnect from network, then:
ovie build
ovie test
# Both should succeed without network

FROM ubuntu:22.04
COPY linux-x64/ovie /usr/local/bin/ovie
COPY linux-x64/oviec /usr/local/bin/oviec
COPY linux-x64/std /usr/local/lib/ovie/std
COPY src/ /app/src/
COPY ovie.toml /app/
WORKDIR /app
CMD ["oviec", "run", "src/main.ov"]

git clone https://github.com/southwarridev/ovie.git
cd ovie
make dev-setup
make dev  # clean + build + test

/// Brief one-line summary
///
/// Longer description if needed.
///
/// # Parameters
/// - param_name: Description of the parameter
///
/// # Returns
/// Description of the return value
///
/// # Examples
/// ```ovie
/// mut result = my_function(42)
/// seeAm result
/// ```
export fn my_function(x: Number) -> Number {
    return x * 2
}