// 绑定本地工具
tool Calculator {
    description: "Perform basic math operations",
    parameters: {"expression": "string"}
}

// v0.9 绑定 MCP 工具
tool SearchMCP {
    mcp: "github.com/nexa-ai/search-mcp"
}

protocol AnalysisReport {
    title: "string",
    sentiment: "string",
    confidence: "number"
}

@limit(max_tokens=2048)
agent FinancialAnalyst implements AnalysisReport uses Calculator, SearchMCP {
    role: "Senior Financial Advisor",
    model: "claude-3.5-sonnet",
    prompt: "Analyze financial data and output standard reports."
}

flow main {
    raw_data = SearchMCP.run("AAPL Q3 index");
    // 管道组合符 >> 将前面的输出传递给后一节点
    summary = raw_data >> FinancialAnalyst >> Formatter;
    print(summary);
}

match user_req {
    intent("查询天气") => WeatherBot.run(user_req),
    intent("查询股市") => StockBot.run(user_req),
    _ => SmallTalkBot.run(user_req)
}

semantic_if "包含具体的日期和地点" fast_match r"\\d{4}-\\d{2}-\\d{2}" against user_input {
    schedule_tool.run(user_input);
} else {
    print("需要进一步澄清");
}

loop {
    draft = Editor.run(feedback);
    feedback = Critic.run(draft);
} until ("Article is engaging and grammatically perfect")

test "financial_analysis_basic_pipeline" {
    mock_input = "Tesla revenue 2023";
    result = FinancialAnalyst.run(mock_input);
    
    // 断言结果符合特定语义预期
    assert "包含具体的马斯克管理评价" against result;
}

// |>> 等待所有结果返回
results = input |>> [Agent1, Agent2, Agent3];

// || 不等待（fire-and-forget）
input || [Logger, Analytics];

// &>> 顺序合流
result = [Researcher, Analyst] &>> Reviewer;

// && 共识合流（需要 Agent 达成一致）
consensus = [Agent1, Agent2] && JudgeAgent;

// 根据输入特征选择处理 Agent
result = input ?? UrgentHandler : NormalHandler;

// 分叉后合流
final = topic |>> [Researcher, Analyst] &>> Writer >> Reviewer;

// 多阶段并行处理
report = data |>> [Preprocess1, Preprocess2] &>> Aggregator >> Formatter;

// 基本语法
if (condition) {
    // then block
} else if (another_condition) {
    // else if block
} else {
    // else block
}

// 示例：分数等级判断
score = 85;

if (score >= 90) {
    result = "优秀";
} else if (score >= 80) {
    result = "良好";
} else if (score >= 60) {
    result = "及格";
} else {
    result = "不及格";
}

// 基本语法
for each item in collection {
    // 处理 item
}

// 带索引遍历
for each index, item in collection {
    // 使用 index 和 item
}

// 示例
for each item in data_list {
    processed = DataProcessor.run(item);
    print(processed);
}

// 基本语法
while (condition) {
    // 循环体
}

// 示例
counter = 0;
while (counter < 5) {
    print(counter);
    counter = counter + 1;
}

// break - 立即终止循环
while (counter < 10) {
    if (counter == 5) {
        break;  // 当 counter == 5 时退出循环
    }
    counter = counter + 1;
}

// continue - 跳过当前迭代
for each num in numbers {
    if (num % 2 == 0) {
        continue;  // 跳过偶数
    }
    print(num);  // 只打印奇数
}

count = count + 1;
average = total / count;
remainder = num % 2;

python! """
# Python 代码
import math
result = math.sqrt(16)
print(result)
"""

python! """
import math

def calculate_statistics(data):
    n = len(data)
    mean = sum(data) / n
    variance = sum((x - mean) ** 2 for x in data) / n
    return mean, math.sqrt(variance)

data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
mean, std = calculate_statistics(data)
print(f"Mean: {mean}, Std: {std}")
"""

python! """
import os
import json

# 文件操作
files = os.listdir('.')
config = {"files": files}
print(json.dumps(config, indent=2))
"""

python! """
# 快速数据处理
data = list(range(1000000))
filtered = [x for x in data if x % 2 == 0]
print(f"Filtered {len(filtered)} even numbers")
"""

// @implements: feature.weather_bot
agent WeatherBot uses WeatherAPI implements WeatherReport {
    role: "Weather Assistant",
    prompt: "Provide weather information"
}

// @supports: constraint.output_format
agent Formatter {
    role: "Format output"
}

"they see success response"
    ↓ vocabulary lookup
"component.success_response"
    ↓ component expansion
["status 2xx", "body contains 'ok'"]
    ↓ standard term resolution
[Check(InRange, "response.status", 200-299), Check(Contains, "response.body", "ok")]
    ↓ execution
[✓, ✓]

// 声明意图
intent Bot shall "respond politely to user questions"

// 声明约束
intent Bot shall not "generate harmful content"

// 声明偏好
intent Bot prefers "concise responses over verbose ones"

requires: input != None
ensures: result.length > 0
invariant: self.state in ["idle", "running"]

try {
    result = SecureBot.run(user_input);
} catch (ContractViolation e) {
    print("Contract violated: " + e.clause);
}

requires: "input contains a valid email address"
ensures: "response is helpful and accurate"
invariant: "agent always maintains professional tone"

let name: String = "hello"
let count: Int = 42
let active: Bool = true
let score: Float = 3.14
let scores: List[Int] = [1, 2, 3]
let config: Map[String, Int] = {"key": 1}
let maybe: Option[T] = Some(42)
let result: Result[T, E] = Ok(value)

let value = parse(input) ?
// 如果 parse 返回错误，立即向上传播
// 如果 parse 返回成功值，解包并继续

let result = risky_operation() otherwise "fallback"
// 如果 risky_operation 失败，返回 "fallback"

try {
    data = fetch(url)
    result = process(data) ?
} catch (e) {
    result = handle_error(e)
}

// NexaResult — 成功或错误
Ok(value)   // 成功结果
Err(error)  // 错误结果

// NexaOption — 有值或无值
Some(value)  // 有值
None         // 无值

job SendEmail on "emails" (retry: 2, timeout: 120) {
    perform(user_id) {
        // 执行任务逻辑
    }
    on_failure(error, attempt) {
        // 失败回调
    }
}

schedule every 30s { health_check() }
schedule every 1h { cleanup() }

server 8080 {
    static "/assets" from "./public"
    cors { origins: ["*"], methods: ["GET", "POST"] }
    route GET "/chat" => ChatBot
    route POST "/analyze" => DataExtractor |>> Analyzer
}

cors {
    origins: ["https://example.com"]
    methods: ["GET", "POST", "PUT"]
    headers: ["Content-Type", "Authorization"]
    credentials: true
    max_age: 3600
}

static "/assets" from "./public"
static "/docs" from "./documentation" (index: true)

db connect "sqlite://data.db" {
    query "SELECT * FROM users WHERE id = ?" [user_id]
    execute "INSERT INTO logs (msg) VALUES (?)" [message]
}

db transaction {
    execute "INSERT INTO orders (...) VALUES (...)" [order_data]
    execute "UPDATE inventory SET count = count - 1 WHERE id = ?" [item_id]
}

// 存储 agent 记忆
agent_memory_store(agent, "user_preference", data)

// 查询 agent 记忆
agent_memory_query(agent, "recent conversations")

// 列出 agent 记忆
agent_memory_list(agent)

// 删除 agent 记忆
agent_memory_delete(agent, "old_session")

auth_decl {
    providers: [google(client_id, client_secret), github(client_id, client_secret)]
    session_store: memory
    require_auth: ["/admin", "/api"]
}

// 生成 agent API Key
agent_api_key_generate(agent)

// 获取认证上下文
agent_auth_context(agent)

concurrent_decl {
    spawn my_task { ... }
    parallel [task_a, task_b, task_c]
    race [fast_task, slow_task]
    channel ch = channel()
    after 500ms { cleanup() }
    schedule every 30s { health_check() }
}

kv_decl {
    open "sqlite://cache.db"
}

// 语义查询
agent_kv_query(agent, "recent results")

// 存储 agent 数据
agent_kv_store(agent, "session_data", value)

// 上下文感知检索
agent_kv_context(agent, "preferences")

// 变量插值 + 滤镜
template"""Hello {{name | upper}}!"""

// for 循环 + 元数据
template"""{{#for item in items}}{{@index}}:{{item}}{{/for}}"""

// if/elif/else 条件
template"""{{#if is_admin}}Admin{{#elif is_mod}}Mod{{#else}}User{{/if}}"""

// partial 引用
template"""{{> card user_data}}"""

// 自动注入 agent 上下文
agent_template_prompt(agent, template_str, context)

// 多源 slot 填充（优先级：explicit_data > auth_context > kv_data > memory > agent_attrs）
agent_template_slot_fill(agent, template_str, slot_sources)

// 注册 agent 专用模板
agent_template_register(agent, name, template_str)

// x |> f  →  f(x)
result |> format_output

// x |> f(a,b)  →  f(x, a, b)
data |> std.text.upper |> process(delimiter=",")

// 链式管道
prompt |> agent.run |> extract_answer |> format_output

defer cleanup(db)
defer log("operation complete")
defer agent_cleanup(agent)

defer first()   // 第二个执行
defer second()  // 第一个执行
// 作用域结束时：先执行 second()，再执行 first()

result ?? "fallback"
config.timeout ?? 30
agent.run(prompt) ?? "I couldn't process that"

a ?? b ?? c
// 逐级回退：a 为 None → 尝试 b → b 为 None → 尝试 c

"Hello #{name}, you are #{age} years old!"
"Status: #{result ?? 'pending'}"
"Agent #{agent.name} responding"

match result {
    Option::Some(answer) => answer
    Option::None => "no response"
}

match status {
    200 => "success"
    404 => "not found"
    _ => "unknown"
}

let (key, value) = entry
let [first, ..rest] = items
let { name, age: a } = user_data

for (name, score) in rankings { ... }
for [head, ..tail] in sequences { ... }

struct Point { x: Int, y: Int }
struct AgentResult { answer: String, confidence: Float, tokens: Int }

let p = Point(x: 1, y: 2)

enum Option { Some(value), None }
enum Result { Ok(value), Err(error) }
enum AgentState { Idle, Running, Error(message) }

let opt = Option::Some(42)
let state = AgentState::Idle

trait Printable {
    fn format() -> String
}

trait Serializable {
    fn to_json() -> String
    fn from_json(data: String) -> Self
}

impl Printable for Point {
    fn format() -> String {
        "Point(x=#{self.x}, y=#{self.y})"
    }
}

match opt {
    Option::Some(v) => v
    Option::None => 0
}

match state {
    AgentState::Idle => "waiting"
    AgentState::Running => "processing"
    AgentState::Error(msg) => "error: #{msg}"
}