main.neva

import {
    fmt
    lists
    os
    runtime
}

type Command struct {
    mode string
    tool string
    prompt string
}

type ToolSpec struct {
    name string
    description string
}

type Request struct {
    command Command
    tools list<ToolSpec>
    message string
}

type ToolCall struct {
    name string
    args string
}

type ToolResult struct {
    output string
}

def Main(start any) (stop any) {
    app App{
        parser ParseCommandFromArgs,
        planner CommandPlanner,
        executor MockToolExecutor
    }
    println fmt.Println<string>
    panic runtime.Panic
    ---
    :start -> app
    app:res -> println
    println:res -> :stop
    [app:err, println:err] -> panic
}

// High-level API surface:
// - parser: CLI model binding
// - planner: request -> tool call planning
// - executor: tool call execution backend
// This mirrors "construct dependencies, then run app" from cmd/neva in Go.
def App(sig any) (res string, err error) {
    parser ICommandParser?
    planner IRequestPlanner
    executor IToolExecutor?

    tools DefaultTools
    req BuildRequest
    out FormatOutput
    ---
    :sig -> [parser, tools]
    parser -> req:command
    tools -> req:tools
    req -> planner -> executor -> out -> :res
}

interface ICommandParser(any) (res Command, err error)

// Minimal strict parser for MVP:
// args[1] => mode, args[2] => tool, args[3] => prompt
// If user passes fewer args, parsing naturally returns compiler.Error.
def ParseCommandFromArgs(sig any) (res Command, err error) {
    args os.Args
    mode lists.At<string>?
    tool lists.At<string>?
    prompt lists.At<string>?
    builder Struct<Command>
    ---
    :sig -> args

    args -> [
        mode:data,
        1 -> mode:idx,

        tool:data,
        2 -> tool:idx,

        prompt:data,
        3 -> prompt:idx
    ]

    mode -> builder:mode
    tool -> builder:tool
    prompt -> builder:prompt
    builder -> :res
}

def DefaultTools(sig any) (res list<ToolSpec>) {
    run_tool Struct<ToolSpec>
    build_tool Struct<ToolSpec>
    to_list lists.FromArray<ToolSpec>
    ---
    :sig -> [
        'neva.run' -> run_tool:name,
        'Compile and run a package' -> run_tool:description,
        'neva.build' -> build_tool:name,
        'Compile package without running' -> build_tool:description
    ]

    run_tool -> to_list:port[0]
    build_tool -> to_list:port[1]
    to_list -> :res
}

def BuildRequest(command Command, tools list<ToolSpec>) (res Request) {
    msg RenderPrompt
    builder Struct<Request>
    ---
    :command -> [msg, builder:command]
    :tools -> builder:tools
    msg -> builder:message
    builder -> :res
}

// Current prompt renderer is intentionally typed and deterministic.
def RenderPrompt(cmd Command) (res string) {
    a Add
    b Add
    c Add
    d Add
    e Add
    ---
    :cmd -> [
        'mode=' -> a:left,
        .mode -> a:right,
        ' tool=' -> b:right,
        .tool -> c:right,
        ' prompt=' -> d:right,
        .prompt -> e:right
    ]
    a -> b:left
    b -> c:left
    c -> d:left
    d -> e:left

    e -> :res
}

interface IRequestPlanner(Request) (res ToolCall)

// CommandPlanner keeps planning policy in one replaceable component.
def CommandPlanner(req Request) (res ToolCall) {
    builder Struct<ToolCall>
    ---
    :req -> [
        .command -> .tool -> builder:name,
        .message -> builder:args
    ]
    builder -> :res
}

interface IToolExecutor(ToolCall) (res ToolResult, err error)

// Placeholder adapter. Replace with real bridge to pkg/cli functionality.
def MockToolExecutor(call ToolCall) (res ToolResult, err error) {
    render RenderMockExecution
    builder Struct<ToolResult>
    ---
    :call -> render -> builder:output
    builder -> :res
}

def RenderMockExecution(call ToolCall) (res string) {
    a Add
    b Add
    c Add
    ---
    :call -> [
        'exec tool=' -> a:left,
        .name -> a:right,
        ' args=' -> b:right,
        .args -> c:right
    ]
    a -> b:left
    b -> c:left

    c -> :res
}

def FormatOutput(result ToolResult) (res string) {
    add_prefix Add
    ---
    :result -> [
        .output -> add_prefix:right,
        'neva-ai> ' -> add_prefix:left
    ]
    add_prefix -> :res
}